Merge branch 'main' into feat/expand-advanced-elicitation-methods

2026-04-03 11:04:11 +02:00 · 2026-04-03 11:04:11 +02:00 · 9bcafdef51
parent 92498ebb52 0edcd0571f
commit 9bcafdef51
237 changed files with 9486 additions and 13655 deletions
--- a/.claude-plugin/marketplace.json
+++ b/.claude-plugin/marketplace.json
@ -0,0 +1,74 @@
 {
  "name": "bmad-method",
  "owner": {
    "name": "Brian (BMad) Madison"
  },
  "description": "Breakthrough Method of Agile AI-driven Development — a full-lifecycle framework with agents and workflows for analysis, planning, architecture, and implementation.",
  "license": "MIT",
  "homepage": "https://github.com/bmad-code-org/BMAD-METHOD",
  "repository": "https://github.com/bmad-code-org/BMAD-METHOD",
  "keywords": ["bmad", "agile", "ai", "orchestrator", "development", "methodology", "agents"],
  "plugins": [
    {
      "name": "bmad-pro-skills",
      "source": "./",
      "description": "Next level skills for power users — advanced prompting techniques, agent management, and more.",
      "version": "6.3.0",
      "author": {
        "name": "Brian (BMad) Madison"
      },
      "skills": [
        "./src/core-skills/bmad-help",
        "./src/core-skills/bmad-brainstorming",
        "./src/core-skills/bmad-distillator",
        "./src/core-skills/bmad-party-mode",
        "./src/core-skills/bmad-shard-doc",
        "./src/core-skills/bmad-advanced-elicitation",
        "./src/core-skills/bmad-editorial-review-prose",
        "./src/core-skills/bmad-editorial-review-structure",
        "./src/core-skills/bmad-index-docs",
        "./src/core-skills/bmad-review-adversarial-general",
        "./src/core-skills/bmad-review-edge-case-hunter"
      ]
    },
    {
      "name": "bmad-method-lifecycle",
      "source": "./",
      "description": "Full-lifecycle AI development framework — agents and workflows for product analysis, planning, architecture, and implementation.",
      "version": "6.3.0",
      "author": {
        "name": "Brian (BMad) Madison"
      },
      "skills": [
        "./src/bmm-skills/1-analysis/bmad-product-brief",
        "./src/bmm-skills/1-analysis/bmad-agent-analyst",
        "./src/bmm-skills/1-analysis/bmad-agent-tech-writer",
        "./src/bmm-skills/1-analysis/bmad-document-project",
        "./src/bmm-skills/1-analysis/research/bmad-domain-research",
        "./src/bmm-skills/1-analysis/research/bmad-market-research",
        "./src/bmm-skills/1-analysis/research/bmad-technical-research",
        "./src/bmm-skills/2-plan-workflows/bmad-agent-pm",
        "./src/bmm-skills/2-plan-workflows/bmad-agent-ux-designer",
        "./src/bmm-skills/2-plan-workflows/bmad-create-prd",
        "./src/bmm-skills/2-plan-workflows/bmad-edit-prd",
        "./src/bmm-skills/2-plan-workflows/bmad-validate-prd",
        "./src/bmm-skills/2-plan-workflows/bmad-create-ux-design",
        "./src/bmm-skills/3-solutioning/bmad-agent-architect",
        "./src/bmm-skills/3-solutioning/bmad-create-architecture",
        "./src/bmm-skills/3-solutioning/bmad-check-implementation-readiness",
        "./src/bmm-skills/3-solutioning/bmad-create-epics-and-stories",
        "./src/bmm-skills/3-solutioning/bmad-generate-project-context",
        "./src/bmm-skills/4-implementation/bmad-agent-dev",
        "./src/bmm-skills/4-implementation/bmad-dev-story",
        "./src/bmm-skills/4-implementation/bmad-quick-dev",
        "./src/bmm-skills/4-implementation/bmad-sprint-planning",
        "./src/bmm-skills/4-implementation/bmad-sprint-status",
        "./src/bmm-skills/4-implementation/bmad-code-review",
        "./src/bmm-skills/4-implementation/bmad-create-story",
        "./src/bmm-skills/4-implementation/bmad-correct-course",
        "./src/bmm-skills/4-implementation/bmad-retrospective",
        "./src/bmm-skills/4-implementation/bmad-qa-generate-e2e-tests"
      ]
    }
  ]
 }
--- a/.github/workflows/publish.yaml
+++ b/.github/workflows/publish.yaml
@ -5,7 +5,7 @@ on:
    branches: [main]
    paths:
      - "src/**"
-      - "tools/cli/**"
+      - "tools/installer/**"
      - "package.json"
  workflow_dispatch:
    inputs:
--- a/README.md
+++ b/README.md
@ -16,7 +16,7 @@ Traditional AI tools do the thinking for you, producing average results. BMad ag
 - **AI Intelligent Help** — Invoke the `bmad-help` skill anytime for guidance on what's next
 - **Scale-Domain-Adaptive** — Automatically adjusts planning depth based on project complexity
 - **Structured Workflows** — Grounded in agile best practices across analysis, planning, architecture, and implementation
- **Specialized Agents** — 12+ domain experts (PM, Architect, Developer, UX, Scrum Master, and more)
+- **Specialized Agents** — 12+ domain experts (PM, Architect, Developer, UX, and more)
 - **Party Mode** — Bring multiple agent personas into one session to collaborate and discuss
 - **Complete Lifecycle** — From brainstorming to deployment
--- a/README_CN.md
+++ b/README_CN.md
@ -16,7 +16,7 @@
 - **AI 智能引导** —— 随时调用 `bmad-help` 获取下一步建议
 - **规模与领域自适应** —— 按项目复杂度自动调整规划深度
 - **结构化工作流** —— 覆盖分析、规划、架构、实施全流程
- **专业角色智能体** —— 提供 PM、架构师、开发者、UX、Scrum Master 等 12+ 角色
+- **专业角色智能体** —— 提供 PM、架构师、开发者、UX 等 12+ 角色
 - **派对模式** —— 多个智能体可在同一会话协作讨论
 - **完整生命周期** —— 从头脑风暴一路到交付上线
--- a/README_VN.md
+++ b/README_VN.md
@ -0,0 +1,110 @@
 ![BMad Method](banner-bmad-method.png)
 [![Version](https://img.shields.io/npm/v/bmad-method?color=blue&label=version)](https://www.npmjs.com/package/bmad-method)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen)](https://nodejs.org)
 [![Discord](https://img.shields.io/badge/Discord-Join%20Community-7289da?logo=discord&logoColor=white)](https://discord.gg/gk8jAdXWmj)
 [English](README.md) | [简体中文](README_CN.md) | Tiếng Việt
 **Build More Architect Dreams** - một mô-đun khung phát triển hướng AI trong hệ sinh thái BMad, có khả năng thích ứng theo quy mô từ sửa lỗi nhỏ đến các hệ thống doanh nghiệp.
 **100% miễn phí và mã nguồn mở.** Không có tường phí. Không có nội dung bị khóa. Không có Discord giới hạn quyền truy cập. Chúng tôi tin vào việc trao quyền cho mọi người, không chỉ cho những ai có thể trả tiền để vào một cộng đồng hay khóa học khép kín.
 ## Vì sao chọn BMad Method?
 Các công cụ AI truyền thống thường làm thay phần suy nghĩ của bạn và tạo ra kết quả ở mức trung bình. Các agent chuyên biệt và quy trình làm việc có hướng dẫn của BMad hoạt động như những cộng tác viên chuyên gia, dẫn dắt bạn qua một quy trình có cấu trúc để khai mở tư duy tốt nhất của bạn cùng với AI.
 - **Trợ giúp AI thông minh** - Gọi skill `bmad-help` bất kỳ lúc nào để biết bước tiếp theo
 - **Thích ứng theo quy mô và miền bài toán** - Tự động điều chỉnh độ sâu lập kế hoạch theo độ phức tạp của dự án
 - **Quy trình có cấu trúc** - Dựa trên các thực hành tốt nhất của agile xuyên suốt phân tích, lập kế hoạch, kiến trúc và triển khai
 - **Agent chuyên biệt** - Hơn 12 chuyên gia theo vai trò như PM, Architect, Developer, UX, Scrum Master và nhiều vai trò khác
 - **Party Mode** - Đưa nhiều persona agent vào cùng một phiên để cộng tác và thảo luận
 - **Vòng đời hoàn chỉnh** - Từ động não ý tưởng cho đến triển khai
 [Tìm hiểu thêm tại **docs.bmad-method.org**](https://docs.bmad-method.org/vi-vn/)
 ---
 ## 🚀 Điều gì tiếp theo cho BMad?
 **V6 đã có mặt và đây mới chỉ là khởi đầu!** BMad Method đang phát triển rất nhanh với các cải tiến như đội agent đa nền tảng và tích hợp sub-agent, kiến trúc Skills, BMad Builder v1, tự động hóa vòng lặp phát triển và nhiều thứ khác vẫn đang được xây dựng.
 **[📍 Xem lộ trình đầy đủ →](https://docs.bmad-method.org/vi-vn/roadmap/)**
 ---
 ## Bắt đầu nhanh
 **Điều kiện tiên quyết**: [Node.js](https://nodejs.org) v20+
 ```bash
 npx bmad-method install
 ```
 > Muốn dùng bản prerelease mới nhất? Hãy dùng `npx bmad-method@next install`. Hãy kỳ vọng mức độ biến động cao hơn bản cài đặt mặc định.
 Làm theo các lời nhắc của trình cài đặt, sau đó mở AI IDE của bạn như Claude Code hoặc Cursor trong thư mục dự án.
 **Cài đặt không tương tác** (cho CI/CD):
 ```bash
 npx bmad-method install --directory /path/to/project --modules bmm --tools claude-code --yes
 ```
 [Xem toàn bộ tùy chọn cài đặt](https://docs.bmad-method.org/vi-vn/how-to/non-interactive-installation/)
 > **Chưa chắc nên làm gì?** Hãy hỏi `bmad-help` - nó sẽ cho bạn biết chính xác bước nào tiếp theo và bước nào là tùy chọn. Bạn cũng có thể hỏi kiểu như `bmad-help Tôi vừa hoàn thành phần kiến trúc, tiếp theo tôi cần làm gì?`
 ## Mô-đun
 BMad Method có thể được mở rộng bằng các mô-đun chính thức cho những miền chuyên biệt. Chúng có sẵn trong lúc cài đặt hoặc bất kỳ lúc nào sau đó.
 | Module                                                                                                            | Mục đích                                           |
 | ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- |
 | **[BMad Method (BMM)](https://github.com/bmad-code-org/BMAD-METHOD)**                                             | Khung lõi với hơn 34 quy trình                     |
 | **[BMad Builder (BMB)](https://github.com/bmad-code-org/bmad-builder)**                                           | Tạo agent và quy trình BMad tùy chỉnh             |
 | **[Test Architect (TEA)](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)**             | Chiến lược kiểm thử và tự động hóa dựa trên rủi ro |
 | **[Game Dev Studio (BMGD)](https://github.com/bmad-code-org/bmad-module-game-dev-studio)**                        | Quy trình phát triển game (Unity, Unreal, Godot)   |
 | **[Creative Intelligence Suite (CIS)](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)** | Đổi mới, động não ý tưởng, tư duy thiết kế         |
 ## Tài liệu
 [Trang tài liệu BMad Method](https://docs.bmad-method.org/vi-vn/) - bài hướng dẫn, hướng dẫn tác vụ, giải thích khái niệm và tài liệu tham chiếu
 **Liên kết nhanh:**
 - [Hướng dẫn bắt đầu](https://docs.bmad-method.org/vi-vn/tutorials/getting-started/)
 - [Nâng cấp từ các phiên bản trước](https://docs.bmad-method.org/vi-vn/how-to/upgrade-to-v6/)
 - [Tài liệu Test Architect](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
 ## Cộng đồng
 - [Discord](https://discord.gg/gk8jAdXWmj) - Nhận trợ giúp, chia sẻ ý tưởng, cộng tác
 - [Đăng ký trên YouTube](https://www.youtube.com/@BMadCode) - video hướng dẫn, lớp chuyên sâu và podcast (ra mắt tháng 2 năm 2025)
 - [GitHub Issues](https://github.com/bmad-code-org/BMAD-METHOD/issues) - Báo lỗi và yêu cầu tính năng
 - [Discussions](https://github.com/bmad-code-org/BMAD-METHOD/discussions) - Trao đổi cộng đồng
 ## Hỗ trợ BMad
 BMad miễn phí cho tất cả mọi người - và sẽ luôn như vậy. Nếu bạn muốn hỗ trợ quá trình phát triển:
 - ⭐ Hãy nhấn sao cho dự án ở góc trên bên phải của trang này
 - ☕ [Buy Me a Coffee](https://buymeacoffee.com/bmad) - Tiếp thêm năng lượng cho quá trình phát triển
 - 🏢 Tài trợ doanh nghiệp - Nhắn riêng trên Discord
 - 🎤 Diễn thuyết và truyền thông - Sẵn sàng cho hội nghị, podcast, phỏng vấn (BM trên Discord)
 ## Đóng góp
 Chúng tôi luôn chào đón đóng góp. Xem [CONTRIBUTING.md](CONTRIBUTING.md) để biết hướng dẫn.
 ## Giấy phép
 Giấy phép MIT - xem [LICENSE](LICENSE) để biết chi tiết.
 ---
 **BMad** và **BMAD-METHOD** là các nhãn hiệu của BMad Code, LLC. Xem [TRADEMARK.md](TRADEMARK.md) để biết chi tiết.
 [![Contributors](https://contrib.rocks/image?repo=bmad-code-org/BMAD-METHOD)](https://github.com/bmad-code-org/BMAD-METHOD/graphs/contributors)
 Xem [CONTRIBUTORS.md](CONTRIBUTORS.md) để biết thông tin về những người đóng góp.
--- a/docs/_STYLE_GUIDE.md
+++ b/docs/_STYLE_GUIDE.md
@ -353,7 +353,7 @@ Only for BMad Method and Enterprise tracks. Quick Flow skips to implementation.
 ### Can I change my plan later?
-Yes. The SM agent has a `bmad-correct-course` workflow for handling scope changes.
+Yes. The `bmad-correct-course` workflow handles scope changes mid-implementation.
 **Have a question not answered here?** [Open an issue](...) or ask in [Discord](...).
 ```
--- a/docs/explanation/analysis-phase.md
+++ b/docs/explanation/analysis-phase.md
@ -0,0 +1,70 @@
 ---
 title: "Analysis Phase: From Idea to Foundation"
 description: What brainstorming, research, product briefs, and PRFAQs are — and when to use each
 sidebar:
  order: 1
 ---
 The Analysis phase (Phase 1) helps you think clearly about your product before committing to building it. Every tool in this phase is optional, but skipping analysis entirely means your PRD is built on assumptions instead of insight.
 ## Why Analysis Before Planning?
 A PRD answers "what should we build and why?" If you feed it vague thinking, you get a vague PRD — and every downstream document inherits that vagueness. Architecture built on a weak PRD makes wrong technical bets. Stories derived from weak architecture miss edge cases. The cost compounds.
 Analysis tools exist to make your PRD sharp. They attack the problem from different angles — creative exploration, market reality, customer clarity, feasibility — so that by the time you sit down with the PM agent, you know what you're building and for whom.
 ## The Tools
 ### Brainstorming
 **What it is.** A facilitated creative session using proven ideation techniques. The AI acts as coach, pulling ideas out of you through structured exercises — not generating ideas for you.
 **Why it's here.** Raw ideas need space to develop before they get locked into requirements. Brainstorming creates that space. It's especially valuable when you have a problem domain but no clear solution, or when you want to explore multiple directions before committing.
 **When to use it.** You have a vague sense of what you want to build but haven't crystallized the concept. Or you have a concept but want to pressure-test it against alternatives.
 See [Brainstorming](./brainstorming.md) for a deeper look at how sessions work.
 ### Research (Market, Domain, Technical)
 **What it is.** Three focused research workflows that investigate different dimensions of your idea. Market research examines competitors, trends, and user sentiment. Domain research builds subject-matter expertise and terminology. Technical research evaluates feasibility, architecture options, and implementation approaches.
 **Why it's here.** Building on assumptions is the fastest way to build something nobody needs. Research grounds your concept in reality — what competitors already exist, what users actually struggle with, what's technically feasible, and what industry-specific constraints you'll face.
 **When to use it.** You're entering an unfamiliar domain, you suspect competitors exist but haven't mapped them, or your concept depends on technical capabilities you haven't validated. Run one, two, or all three — each stands alone.
 ### Product Brief
 **What it is.** A guided discovery session that produces a 1-2 page executive summary of your product concept. The AI acts as a collaborative Business Analyst, helping you articulate the vision, target audience, value proposition, and scope.
 **Why it's here.** The product brief is the gentler path into planning. It captures your strategic vision in a structured format that feeds directly into PRD creation. It works best when you already have conviction about your concept — you know the customer, the problem, and roughly what you want to build. The brief organizes and sharpens that thinking.
 **When to use it.** Your concept is relatively clear and you want to document it efficiently before creating a PRD. You're confident in the direction and don't need your assumptions aggressively challenged.
 ### PRFAQ (Working Backwards)
 **What it is.** Amazon's Working Backwards methodology adapted as an interactive challenge. You write the press release announcing your finished product before a single line of code exists, then answer the hardest questions customers and stakeholders would ask. The AI acts as a relentless but constructive product coach.
 **Why it's here.** The PRFAQ is the rigorous path into planning. It forces customer-first clarity by making you defend every claim. If you can't write a compelling press release, the product isn't ready. If customer FAQ answers reveal gaps, those are gaps you'd discover much later — and more expensively — during implementation. The gauntlet surfaces weak thinking early, when it's cheapest to fix.
 **When to use it.** You want your concept stress-tested before committing resources. You're unsure whether users will actually care. You want to validate that you can articulate a clear, defensible value proposition. Or you simply want the discipline of Working Backwards to sharpen your thinking.
 ## Which Should I Use?
 | Situation | Recommended tool |
 | --------- | ---------------- |
 | "I have a vague idea, not sure where to start" | Brainstorming |
 | "I need to understand the market before deciding" | Research |
 | "I know what I want to build, just need to document it" | Product Brief |
 | "I want to make sure this idea is actually worth building" | PRFAQ |
 | "I want to explore, then validate, then document" | Brainstorming → Research → PRFAQ or Brief |
 Product Brief and PRFAQ both produce input for the PRD — choose one based on how much challenge you want. The brief is collaborative discovery. The PRFAQ is a gauntlet. Both get you to the same destination; the PRFAQ tests whether your concept deserves to get there.
 :::tip[Not Sure?]
 Run `bmad-help` and describe your situation. It will recommend the right starting point based on what you've already done and what you're trying to accomplish.
 :::
 ## What Happens After Analysis?
 Analysis outputs feed directly into Phase 2 (Planning). The PRD workflow accepts product briefs, PRFAQ documents, research findings, and brainstorming reports as input — it synthesizes whatever you've produced into structured requirements. The more analysis you do, the sharper your PRD.
--- a/docs/explanation/checkpoint-preview.md
+++ b/docs/explanation/checkpoint-preview.md
@ -0,0 +1,92 @@
 ---
 title: "Checkpoint Preview"
 description: LLM-assisted human-in-the-loop review that guides you through a change from purpose to details
 sidebar:
  order: 3
 ---
 `bmad-checkpoint-preview` is an interactive, LLM-assisted human-in-the-loop review workflow. It walks you through a code change — from purpose and context into details — so you can make an informed decision about whether to ship, rework, or dig deeper.
 ![Checkpoint Preview workflow diagram](/diagrams/checkpoint-preview-diagram.png)
 ## The Typical Flow
 You run `bmad-quick-dev`. It clarifies your intent, builds a spec, implements the change, and when it's done it appends a review trail to the spec file and opens it in your editor. You look at the spec and see the change touched 20 files across several modules.
 You could eyeball the diff. But 20 files is where eyeballing starts to fail — you lose the thread, miss a connection between two distant changes, or approve something you didn't fully understand. So instead, you say "checkpoint" and the LLM walks you through it.
 That handoff — from autonomous implementation back to human judgment — is the primary use case. Quick-dev runs long with minimal supervision. Checkpoint Preview is where you take back the wheel.
 ## Why It Exists
 Code review has two failure modes. In one, the reviewer skims the diff, nothing jumps out, and they approve. In the other, they methodically read every file but lose the thread — they see the trees and miss the forest. Both result in the same outcome: the review didn't catch the thing that mattered.
 The underlying issue is sequencing. A raw diff presents changes in file order, which is almost never the order that builds understanding. You see a helper function before you know why it exists. You see a schema change before you understand what feature it supports. The reviewer has to reconstruct the author's intent from scattered clues, and that reconstruction is where attention fails.
 Checkpoint Preview solves this by making the LLM do the reconstruction work. It reads the diff, the spec (if one exists), and the surrounding codebase, then presents the change in an order designed for comprehension — not for `git diff`.
 ## How It Works
 The workflow has five steps. Each step builds on the previous one, progressively shifting from "what is this?" toward "should we ship it?"
 ### 1. Orientation
 The workflow identifies the change (from a PR, commit, branch, spec file, or the current git state) and produces a one-line intent summary plus surface area stats: files changed, modules touched, lines of logic, boundary crossings, and new public interfaces.
 This is the "is this what I think it is?" moment. Before reading any code, the reviewer confirms they're looking at the right thing and calibrates their expectations for scope.
 ### 2. Walkthrough
 The change is organized by **concern** — cohesive design intents like "input validation" or "API contract" — not by file. Each concern gets a short explanation of *why* this approach was chosen, followed by clickable `path:line` stops that the reviewer can follow through the code.
 This is the design judgment step. The reviewer evaluates whether the approach is right for the system, not whether the code is correct. Concerns are sequenced top-down: the highest-level intent first, then supporting implementation. The reviewer never encounters a reference to something they haven't seen yet.
 ### 3. Detail Pass
 After the reviewer understands the design, the workflow surfaces 2-5 spots where a mistake would have the highest blast radius. These are tagged by risk category — `[auth]`, `[schema]`, `[billing]`, `[public API]`, `[security]`, and others — and ordered by how much breaks if they're wrong.
 This is not a bug hunt. Automated tests and CI handle correctness. The detail pass activates risk awareness: "here are the places where being wrong costs the most." If the reviewer wants to go deeper on a specific area, they can say "dig into [area]" for a targeted correctness-focused re-review.
 If the spec went through adversarial review loops (machine hardening), those findings are surfaced here too — not the bugs that were fixed, but the decisions that the review loop flagged that the reviewer should be aware of.
 ### 4. Testing
 Suggests 2-5 ways to manually observe the change working. Not automated test commands — manual observations that build confidence no test suite provides. A UI interaction to try, a CLI command to run, an API request to send, with expected results for each.
 If the change has no user-visible behavior, it says so. No invented busywork.
 ### 5. Wrap-Up
 The reviewer makes the call: approve, rework, or keep discussing. If approving a PR, the workflow can help with `gh pr review --approve`. If reworking, it helps diagnose whether the problem was the approach, the spec, or the implementation, and helps draft actionable feedback tied to specific code locations.
 ## It's a Conversation, Not a Report
 The workflow presents each step as a starting point, not a final word. Between steps — or in the middle of one — you can talk to the LLM, ask questions, challenge its framing, or pull in other skills to get a different perspective:
 - **"run advanced elicitation on the error handling"** — push the LLM to reconsider and refine its analysis of a specific area
 - **"party mode on whether this schema migration is safe"** — bring multiple agent perspectives into a focused debate
 - **"run code review"** — generate structured agentic findings with adversarial and edge-case analysis
 The checkpoint workflow doesn't lock you into a linear path. It gives you structure when you want it and gets out of the way when you want to explore. The five steps are there to make sure you see the whole picture, but how deep you go at each step — and what tools you bring in — is entirely up to you.
 ## The Review Trail
 The walkthrough step works best when it has a **Suggested Review Order** — a list of stops the spec author wrote to guide reviewers through the change. When a spec includes this, the workflow uses it directly.
 When no author-produced trail exists, the workflow generates one from the diff and codebase context. A generated trail is lower quality than an author-produced one, but far better than reading changes in file order.
 ## When to Use It
 The primary scenario is the handoff from `bmad-quick-dev`: the implementation is done, the spec file is open in your editor with a review trail appended, and you need to decide whether to ship. Say "checkpoint" and go.
 It also works standalone:
 - **Reviewing a PR** — especially one with more than a handful of files or cross-cutting changes
 - **Onboarding to a change** — when you need to understand what happened on a branch you didn't write
 - **Sprint review** — the workflow can pick up stories marked `review` in your sprint status file
 Invoke it by saying "checkpoint" or "walk me through this change." It works in any terminal, but you'll get more out of it inside an IDE — VS Code, Cursor, or similar — because the workflow produces `path:line` references at every step. In an IDE-embedded terminal those are clickable, so you can jump from file to file as you follow the review trail.
 ## What It Is Not
 Checkpoint Preview is not a substitute for automated review. It does not run linters, type checkers, or test suites. It does not assign severity scores or produce pass/fail verdicts. It is a reading guide that helps a human apply their judgment where it matters most.
--- a/docs/fr/how-to/non-interactive-installation.md
+++ b/docs/fr/how-to/non-interactive-installation.md
@ -37,7 +37,19 @@ Nécessite [Node.js](https://nodejs.org) v20+ et `npx` (inclus avec npm).
 | `--user-name <nom>` | Nom à utiliser par les agents | Nom d'utilisateur système |
 | `--communication-language <langue>` | Langue de communication des agents | Anglais |
 | `--document-output-language <langue>` | Langue de sortie des documents | Anglais |
-| `--output-folder <chemin>` | Chemin du dossier de sortie | _bmad-output |
+| `--output-folder <chemin>` | Chemin du dossier de sortie (voir les règles de résolution ci-dessous) | `_bmad-output` |
 #### Résolution du chemin du dossier de sortie
 La valeur passée à `--output-folder` (ou saisie de manière interactive) est résolue selon ces règles :
 | Type d'entrée                 | Exemple                    | Résolu comme                                                 |
 |-------------------------------|----------------------------|--------------------------------------------------------------|
 | Chemin relatif (par défaut)   | `_bmad-output`             | `<racine-du-projet>/_bmad-output`                            |
 | Chemin relatif avec traversée | `../../shared-outputs`     | Chemin absolu normalisé — ex. `/Users/me/shared-outputs`     |
 | Chemin absolu                 | `/Users/me/shared-outputs` | Utilisé tel quel — la racine du projet n'est **pas** ajoutée |
 Le chemin résolu est ce que les agents et les workflows vont utiliser lors de l'écriture des fichiers de sortie. L'utilisation d'un chemin absolu ou d'un chemin relatif avec traversée vous permet de diriger tous les artefacts générés vers un répertoire en dehors de l'arborescence de votre projet — utile pour les configurations partagées ou les monorepos.
 ### Autres options
@ -61,7 +73,7 @@ IDs d'outils disponibles pour l’option `--tools` :
 **Recommandés :** `claude-code`, `cursor`
-Exécutez `npx bmad-method install` de manière interactive une fois pour voir la liste complète actuelle des outils pris en charge, ou consultez la [configuration des codes de la plateforme](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/cli/installers/lib/ide/platform-codes.yaml).
+Exécutez `npx bmad-method install` de manière interactive une fois pour voir la liste complète actuelle des outils pris en charge, ou consultez la [configuration des codes de la plateforme](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/installer/ide/platform-codes.yaml).
 ## Modes d'installation
@ -141,6 +153,7 @@ Les valeurs invalides entraîneront soit :
 :::tip[Bonnes pratiques]
 - Utilisez des chemins absolus pour `--directory` pour éviter toute ambiguïté
 - Utilisez un chemin absolu pour `--output-folder` lorsque vous souhaitez que les artefacts soient écrits en dehors de l'arborescence du projet (ex. un répertoire de sorties partagé dans un monorepo)
 - Testez les options localement avant de les utiliser dans des pipelines CI/CD
 - Combinez avec `-y` pour des installations vraiment sans surveillance
 - Utilisez `--debug` si vous rencontrez des problèmes lors de l'installation
--- a/docs/fr/reference/agents.md
+++ b/docs/fr/reference/agents.md
@ -1,13 +1,13 @@
 ---
 title: Agents
-description: Agents BMM par défaut avec leurs identifiants de skill, déclencheurs de menu et workflows principaux (Analyst, Architect, UX Designer, Technical Writer)
+description: Agents BMM par défaut avec leurs identifiants de skill, déclencheurs de menu et workflows principaux (Analyst, Developer, Architect, UX Designer, Technical Writer)
 sidebar:
  order: 2
 ---
 ## Agents par défaut
-Cette page liste les quatre agents BMM (suite Agile) par défaut installés avec la méthode BMad, ainsi que leurs identifiants de skill, déclencheurs de menu et workflows principaux. Chaque agent est invoqué en tant que skill.
+Cette page liste les cinq agents BMM (suite Agile) par défaut installés avec la méthode BMad, ainsi que leurs identifiants de skill, déclencheurs de menu et workflows principaux. Chaque agent est invoqué en tant que skill.
 ## Notes
@ -19,6 +19,7 @@ Cette page liste les quatre agents BMM (suite Agile) par défaut installés avec
 |------------------------|----------------------|------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | Analyste (Mary)        | `bmad-analyst`       | `BP`, `MR`, `DR`, `TR`, `CB`, `DP` | Brainstorming du projet, Recherche marché/domaine/technique, Création du brief[^1], Documentation du projet                                                    |
 | Architecte (Winston)   | `bmad-architect`     | `CA`, `IR`                         | Créer l’architecture, Préparation à l’implémentation                                                                                                           |
 | Développeur (Amelia)   | `bmad-dev`           | `DS`, `QD`, `CR`                   | Dev Story, Quick Dev, Code Review                                                                                                                              |
 | Designer UX (Sally)    | `bmad-ux-designer`   | `CU`                               | Création du design UX[^2]                                                                                                                                      |
 | Rédacteur Technique (Paige) | `bmad-tech-writer` | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Documentation du projet, Rédaction de documents, Mise à jour des standards, Génération de diagrammes Mermaid, Validation de documents, Explication de concepts |
--- a/docs/fr/reference/testing.md
+++ b/docs/fr/reference/testing.md
@ -24,9 +24,9 @@ La plupart des projets devraient commencer avec le workflow QA intégré. Si vou
 ## Workflow QA Intégré
-Le workflow QA intégré est inclus dans le module BMM (suite Agile). Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
+Le workflow QA intégré (`bmad-qa-generate-e2e-tests`) fait partie du module BMM (suite Agile), disponible via l'agent Developer. Il génère rapidement des tests fonctionnels en utilisant le framework de test existant de votre projet — aucune configuration ni installation supplémentaire requise.
-**Déclencheur :** `QA` ou `bmad-qa-generate-e2e-tests`
+**Déclencheur :** `QA` (via l'agent Developer) ou `bmad-qa-generate-e2e-tests`
 ### Ce que le Workflow QA Fait
@ -98,7 +98,7 @@ TEA supporte également la priorisation basée sur les risques P0-P3 et des int
 Le workflow Automate du QA intégré apparaît dans la Phase 4 (Implémentation) de la carte de workflow méthode BMad. Il est conçu pour s'exécuter **après qu'un epic complet soit terminé** — une fois que toutes les stories d'un epic ont été implémentées et revues. Une séquence typique :
 1. Pour chaque story de l'epic : implémenter avec Dev Story (`DS`), puis valider avec Code Review (`CR`)
-2. Après la fin de l'epic : générer les tests avec le workflow QA (`QA`) ou le workflow Automate de TEA
+2. Après la fin de l'epic : générer les tests avec `QA` (via l'agent Developer) ou le workflow Automate de TEA
 3. Lancer la rétrospective (`bmad-retrospective`) pour capturer les leçons apprises
 Le workflow QA travaille directement à partir du code source sans charger les documents de planification (PRD, architecture). Les workflows TEA peuvent s'intégrer avec les artefacts de planification en amont pour la traçabilité.
--- a/docs/how-to/non-interactive-installation.md
+++ b/docs/how-to/non-interactive-installation.md
@ -37,7 +37,19 @@ Requires [Node.js](https://nodejs.org) v20+ and `npx` (included with npm).
 | `--user-name <name>` | Name for agents to use | System username |
 | `--communication-language <lang>` | Agent communication language | English |
 | `--document-output-language <lang>` | Document output language | English |
-| `--output-folder <path>` | Output folder path | _bmad-output |
+| `--output-folder <path>` | Output folder path (see resolution rules below) | `_bmad-output` |
 #### Output Folder Path Resolution
 The value passed to `--output-folder` (or entered interactively) is resolved according to these rules:
 | Input type | Example | Resolved as |
 |------------|---------|-------------|
 | Relative path (default) | `_bmad-output` | `<project-root>/_bmad-output` |
 | Relative path with traversal | `../../shared-outputs` | Normalized absolute path — e.g. `/Users/me/shared-outputs` |
 | Absolute path | `/Users/me/shared-outputs` | Used as-is — project root is **not** prepended |
 The resolved path is what agents and workflows use at runtime when writing output files. Using an absolute path or a traversal-based relative path lets you direct all generated artifacts to a directory outside your project tree — useful for shared or monorepo setups.
 ### Other Options
@ -61,7 +73,7 @@ Available tool IDs for the `--tools` flag:
 **Preferred:** `claude-code`, `cursor`
-Run `npx bmad-method install` interactively once to see the full current list of supported tools, or check the [platform codes configuration](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/cli/installers/lib/ide/platform-codes.yaml).
+Run `npx bmad-method install` interactively once to see the full current list of supported tools, or check the [platform codes configuration](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/installer/ide/platform-codes.yaml).
 ## Installation Modes
@ -141,6 +153,7 @@ Invalid values will either:
 :::tip[Best Practices]
 - Use absolute paths for `--directory` to avoid ambiguity
 - Use an absolute path for `--output-folder` when you want artifacts written outside the project tree (e.g. a shared monorepo outputs directory)
 - Test flags locally before using in CI/CD pipelines
 - Combine with `-y` for truly unattended installations
 - Use `--debug` if you encounter issues during installation
--- a/docs/how-to/upgrade-to-v6.md
+++ b/docs/how-to/upgrade-to-v6.md
@ -61,8 +61,8 @@ If you have stories created or implemented:
 1. Complete the v6 installation
 2. Place `epics.md` or `epics/epic*.md` in `_bmad-output/planning-artifacts/`
-3. Run the Scrum Master's `bmad-sprint-planning` workflow
+3. Run the Developer's `bmad-sprint-planning` workflow
-4. Tell the SM which epics/stories are already complete
+4. Tell the agent which epics/stories are already complete
 ## What You Get
--- a/docs/reference/agents.md
+++ b/docs/reference/agents.md
@ -13,17 +13,14 @@ This page lists the default BMM (Agile suite) agents that install with BMad Meth
 - Each agent is available as a skill, generated by the installer. The skill ID (e.g., `bmad-dev`) is used to invoke the agent.
 - Triggers are the short menu codes (e.g., `CP`) and fuzzy matches shown in each agent menu.
- QA (Quinn) is the lightweight test automation agent in BMM. The full Test Architect (TEA) lives in its own module.
+- QA test generation is handled by the `bmad-qa-generate-e2e-tests` workflow skill, available through the Developer agent. The full Test Architect (TEA) lives in its own module.
 | Agent                       | Skill ID             | Triggers                           | Primary workflows                                                                                   |
 | --------------------------- | -------------------- | ---------------------------------- | --------------------------------------------------------------------------------------------------- |
-| Analyst (Mary)              | `bmad-analyst`       | `BP`, `RS`, `CB`, `DP`             | Brainstorm Project, Research, Create Brief, Document Project                                        |
+| Analyst (Mary)              | `bmad-analyst`       | `BP`, `RS`, `CB`, `WB`, `DP`       | Brainstorm Project, Research, Create Brief, PRFAQ Challenge, Document Project                       |
 | Product Manager (John)      | `bmad-pm`            | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | Create/Validate/Edit PRD, Create Epics and Stories, Implementation Readiness, Correct Course        |
 | Architect (Winston)         | `bmad-architect`     | `CA`, `IR`                         | Create Architecture, Implementation Readiness                                                       |
-| Scrum Master (Bob)          | `bmad-sm`            | `SP`, `CS`, `ER`, `CC`             | Sprint Planning, Create Story, Epic Retrospective, Correct Course                                   |
+| Developer (Amelia)          | `bmad-agent-dev`     | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER` | Dev Story, Quick Dev, QA Test Generation, Code Review, Sprint Planning, Create Story, Epic Retrospective |
 | Developer (Amelia)          | `bmad-dev`           | `DS`, `CR`                         | Dev Story, Code Review                                                                              |
 | QA Engineer (Quinn)         | `bmad-qa`            | `QA`                               | Automate (generate tests for existing features)                                                     |
 | Quick Flow Solo Dev (Barry) | `bmad-master`        | `QD`, `CR`                          | Quick Dev, Code Review                                                                              |
 | UX Designer (Sally)         | `bmad-ux-designer`   | `CU`                               | Create UX Design                                                                                    |
 | Technical Writer (Paige)    | `bmad-tech-writer`   | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Document Project, Write Document, Update Standards, Mermaid Generate, Validate Doc, Explain Concept |
--- a/docs/reference/commands.md
+++ b/docs/reference/commands.md
@ -54,12 +54,12 @@ Each skill is a directory containing a `SKILL.md` file. For example, a Claude Co
 │   └── SKILL.md
 ├── bmad-create-prd/
 │   └── SKILL.md
-├── bmad-dev/
+├── bmad-agent-dev/
 │   └── SKILL.md
 └── ...
 ```
-The directory name determines the skill name in your IDE. For example, the directory `bmad-dev/` registers the skill `bmad-dev`.
+The directory name determines the skill name in your IDE. For example, the directory `bmad-agent-dev/` registers the skill `bmad-agent-dev`.
 ## How to Discover Your Skills
@ -79,10 +79,9 @@ Agent skills load a specialized AI persona with a defined role, communication st
 | Example skill | Agent | Role |
 | --- | --- | --- |
-| `bmad-dev` | Amelia (Developer) | Implements stories with strict adherence to specs |
+| `bmad-agent-dev` | Amelia (Developer) | Implements stories with strict adherence to specs |
 | `bmad-pm` | John (Product Manager) | Creates and validates PRDs |
 | `bmad-architect` | Winston (Architect) | Designs system architecture |
 | `bmad-sm` | Bob (Scrum Master) | Manages sprints and stories |
 See [Agents](./agents.md) for the full list of default agents and their triggers.
@ -92,6 +91,8 @@ Workflow skills run a structured, multi-step process without loading an agent pe
 | Example skill | Purpose |
 | --- | --- |
 | `bmad-product-brief` | Create a product brief — guided discovery when your concept is clear |
 | `bmad-prfaq` | Working Backwards PRFAQ challenge to stress-test your product concept |
 | `bmad-create-prd` | Create a Product Requirements Document |
 | `bmad-create-architecture` | Design system architecture |
 | `bmad-create-epics-and-stories` | Create epics and stories |
@ -123,7 +124,7 @@ The core module includes 11 built-in tools — reviews, compression, brainstormi
 ## Naming Convention
-All skills use the `bmad-` prefix followed by a descriptive name (e.g., `bmad-dev`, `bmad-create-prd`, `bmad-help`). See [Modules](./modules.md) for available modules.
+All skills use the `bmad-` prefix followed by a descriptive name (e.g., `bmad-agent-dev`, `bmad-create-prd`, `bmad-help`). See [Modules](./modules.md) for available modules.
 ## Troubleshooting
--- a/docs/reference/testing.md
+++ b/docs/reference/testing.md
@ -1,15 +1,15 @@
 ---
 title: Testing Options
-description: Comparing the built-in QA agent (Quinn) with the Test Architect (TEA) module for test automation.
+description: Comparing the built-in QA workflow with the Test Architect (TEA) module for test automation.
 sidebar:
  order: 5
 ---
-BMad provides two testing paths: a built-in QA agent for fast test generation and an installable Test Architect module for enterprise-grade test strategy.
+BMad provides two testing paths: a built-in QA workflow for fast test generation and an installable Test Architect module for enterprise-grade test strategy.
 ## Which Should You Use?
-| Factor | Quinn (Built-in QA) | TEA Module |
+| Factor | Built-in QA | TEA Module |
 | --- | --- | --- |
 | **Best for** | Small-medium projects, quick coverage | Large projects, regulated or complex domains |
 | **Setup** | Nothing to install -- included in BMM | Install separately via `npx bmad-method install` |
@ -18,19 +18,19 @@ BMad provides two testing paths: a built-in QA agent for fast test generation an
 | **Strategy** | Happy path + critical edge cases | Risk-based prioritization (P0-P3) |
 | **Workflow count** | 1 (Automate) | 9 (design, ATDD, automate, review, trace, and others) |
-:::tip[Start with Quinn]
+:::tip[Start with built-in QA]
-Most projects should start with Quinn. If you later need test strategy, quality gates, or requirements traceability, install TEA alongside it.
+Most projects should start with the built-in QA workflow. If you later need test strategy, quality gates, or requirements traceability, install TEA alongside it.
 :::
-## Built-in QA Agent (Quinn)
+## Built-in QA Workflow
-Quinn is the built-in QA agent in the BMM (Agile suite) module. It generates working tests quickly using your project's existing test framework -- no configuration or additional installation required.
+The built-in QA workflow (`bmad-qa-generate-e2e-tests`) is part of the BMM (Agile suite) module, available through the Developer agent. It generates working tests quickly using your project's existing test framework -- no configuration or additional installation required.
-**Trigger:** `QA` or `bmad-qa-generate-e2e-tests`
+**Trigger:** `QA` (via the Developer agent) or `bmad-qa-generate-e2e-tests`
-### What Quinn Does
+### What It Does
-Quinn runs a single workflow (Automate) that walks through five steps:
+The QA workflow (Automate) walks through five steps:
 1. **Detect test framework** -- scans `package.json` and existing test files for your framework (Jest, Vitest, Playwright, Cypress, or any standard runner). If none exists, analyzes the project stack and suggests one.
 2. **Identify features** -- asks what to test or auto-discovers features in the codebase.
@ -38,7 +38,7 @@ Quinn runs a single workflow (Automate) that walks through five steps:
 4. **Generate E2E tests** -- covers user workflows with semantic locators and visible-outcome assertions.
 5. **Run and verify** -- executes the generated tests and fixes failures immediately.
-Quinn produces a test summary saved to your project's implementation artifacts folder.
+The workflow produces a test summary saved to your project's implementation artifacts folder.
 ### Test Patterns
@ -51,10 +51,10 @@ Generated tests follow a "simple and maintainable" philosophy:
 - **Clear descriptions** that read as feature documentation
 :::note[Scope]
-Quinn generates tests only. For code review and story validation, use the Code Review workflow (`CR`) instead.
+The QA workflow generates tests only. For code review and story validation, use the Code Review workflow (`CR`) instead.
 :::
-### When to Use Quinn
+### When to Use Built-in QA
 - Quick test coverage for a new or existing feature
 - Beginner-friendly test automation without advanced setup
@ -91,16 +91,16 @@ TEA also supports P0-P3 risk-based prioritization and optional integrations with
 - Teams that need risk-based test prioritization across many features
 - Enterprise environments with formal quality gates before release
 - Complex domains where test strategy must be planned before tests are written
- Projects that have outgrown Quinn's single-workflow approach
+- Projects that have outgrown the built-in QA's single-workflow approach
 ## How Testing Fits into Workflows
-Quinn's Automate workflow appears in Phase 4 (Implementation) of the BMad Method workflow map. It is designed to run **after a full epic is complete** — once all stories in an epic have been implemented and code-reviewed. A typical sequence:
+The QA Automate workflow appears in Phase 4 (Implementation) of the BMad Method workflow map. It is designed to run **after a full epic is complete** — once all stories in an epic have been implemented and code-reviewed. A typical sequence:
 1. For each story in the epic: implement with Dev (`DS`), then validate with Code Review (`CR`)
-2. After the epic is complete: generate tests with Quinn (`QA`) or TEA's Automate workflow
+2. After the epic is complete: generate tests with `QA` (via the Developer agent) or TEA's Automate workflow
 3. Run retrospective (`bmad-retrospective`) to capture lessons learned
-Quinn works directly from source code without loading planning documents (PRD, architecture). TEA workflows can integrate with upstream planning artifacts for traceability.
+The built-in QA workflow works directly from source code without loading planning documents (PRD, architecture). TEA workflows can integrate with upstream planning artifacts for traceability.
 For more on where testing fits in the overall process, see the [Workflow Map](./workflow-map.md).
--- a/docs/reference/workflow-map.md
+++ b/docs/reference/workflow-map.md
@ -21,13 +21,14 @@ Final important note: Every workflow below can be run directly with your tool of
 ## Phase 1: Analysis (Optional)
-Explore the problem space and validate ideas before committing to planning.
+Explore the problem space and validate ideas before committing to planning. [**Learn what each tool does and when to use it**](../explanation/analysis-phase.md).
 | Workflow                        | Purpose                                                                    | Produces                  |
 | ------------------------------- | -------------------------------------------------------------------------- | ------------------------- |
 | `bmad-brainstorming`            | Brainstorm Project Ideas with guided facilitation of a brainstorming coach | `brainstorming-report.md` |
 | `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Validate market, technical, or domain assumptions | Research findings |
-| `bmad-create-product-brief`     | Capture strategic vision                                                   | `product-brief.md`        |
+| `bmad-product-brief`            | Capture strategic vision — best when your concept is clear                 | `product-brief.md`        |
 | `bmad-prfaq`                    | Working Backwards — stress-test and forge your product concept             | `prfaq-{project}.md`      |
 ## Phase 2: Planning
--- a/docs/tutorials/getting-started.md
+++ b/docs/tutorials/getting-started.md
@ -68,7 +68,7 @@ BMad helps you build software through guided workflows with specialized AI agent
 | Phase | Name           | What Happens                                        |
 | ----- | -------------- | --------------------------------------------------- |
-| 1     | Analysis       | Brainstorming, research, product brief *(optional)* |
+| 1     | Analysis       | Brainstorming, research, product brief or PRFAQ *(optional)* |
 | 2     | Planning       | Create requirements (PRD or spec)              |
 | 3     | Solutioning    | Design architecture *(BMad Method/Enterprise only)* |
 | 4     | Implementation | Build epic by epic, story by story                  |
@ -133,10 +133,11 @@ Create it manually at `_bmad-output/project-context.md` or generate it after arc
 ### Phase 1: Analysis (Optional)
-All workflows in this phase are optional:
+All workflows in this phase are optional. [**Not sure which to use?**](../explanation/analysis-phase.md)
 - **brainstorming** (`bmad-brainstorming`) — Guided ideation
 - **research** (`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) — Market, domain, and technical research
- **create-product-brief** (`bmad-create-product-brief`) — Recommended foundation document
+- **product-brief** (`bmad-product-brief`) — Recommended foundation document when your concept is clear
 - **prfaq** (`bmad-prfaq`) — Working Backwards challenge to stress-test and forge your product concept
 ### Phase 2: Planning (Required)
@ -180,7 +181,7 @@ Once planning is complete, move to implementation. **Each workflow should run in
 ### Initialize Sprint Planning
-Invoke the **SM agent** (`bmad-agent-sm`) and run `bmad-sprint-planning` (`bmad-sprint-planning`). This creates `sprint-status.yaml` to track all epics and stories.
+Invoke the **Developer agent** (`bmad-agent-dev`) and run `bmad-sprint-planning` (`bmad-sprint-planning`). This creates `sprint-status.yaml` to track all epics and stories.
 ### The Build Cycle
@ -188,11 +189,11 @@ For each story, repeat this cycle with fresh chats:
 | Step | Agent | Workflow       | Command                    | Purpose                            |
 | ---- | ----- | -------------- | -------------------------- | ---------------------------------- |
-| 1    | SM    | `bmad-create-story` | `bmad-create-story`  | Create story file from epic        |
+| 1    | DEV   | `bmad-create-story` | `bmad-create-story`  | Create story file from epic        |
 | 2    | DEV   | `bmad-dev-story`    | `bmad-dev-story`     | Implement the story                |
 | 3    | DEV   | `bmad-code-review`  | `bmad-code-review`   | Quality validation *(recommended)* |
-After completing all stories in an epic, invoke the **SM agent** (`bmad-agent-sm`) and run `bmad-retrospective` (`bmad-retrospective`).
+After completing all stories in an epic, invoke the **Developer agent** (`bmad-agent-dev`) and run `bmad-retrospective` (`bmad-retrospective`).
 ## What You've Accomplished
@ -229,8 +230,8 @@ your-project/
 | `bmad-generate-project-context`       | `bmad-generate-project-context`           | Analyst   | Create project context file                     |
 | `bmad-create-epics-and-stories`       | `bmad-create-epics-and-stories`       | PM        | Break down PRD into epics            |
 | `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Validate planning cohesion           |
-| `bmad-sprint-planning`                | `bmad-sprint-planning`                | SM        | Initialize sprint tracking           |
+| `bmad-sprint-planning`                | `bmad-sprint-planning`                | DEV       | Initialize sprint tracking           |
-| `bmad-create-story`                   | `bmad-create-story`                   | SM        | Create a story file                  |
+| `bmad-create-story`                   | `bmad-create-story`                   | DEV       | Create a story file                  |
 | `bmad-dev-story`                      | `bmad-dev-story`                      | DEV       | Implement a story                    |
 | `bmad-code-review`                    | `bmad-code-review`                    | DEV       | Review implemented code              |
@ -240,7 +241,7 @@ your-project/
 Only for BMad Method and Enterprise tracks. Quick Flow skips from spec to implementation.
 **Can I change my plan later?**
-Yes. The SM agent has a `bmad-correct-course` workflow (`bmad-correct-course`) for handling scope changes.
+Yes. The `bmad-correct-course` workflow handles scope changes mid-implementation.
 **What if I want to brainstorm first?**
 Invoke the Analyst agent (`bmad-agent-analyst`) and run `bmad-brainstorming` (`bmad-brainstorming`) before starting your PRD.
--- a/docs/vi-vn/404.md
+++ b/docs/vi-vn/404.md
@ -0,0 +1,8 @@
 ---
 title: Không Tìm Thấy Trang
 template: splash
 ---
 Trang bạn đang tìm không tồn tại hoặc đã được chuyển đi.
 [Quay về trang chủ](./index.md)
--- a/docs/vi-vn/_STYLE_GUIDE.md
+++ b/docs/vi-vn/_STYLE_GUIDE.md
@ -0,0 +1,370 @@
 ---
 title: "Hướng Dẫn Phong Cách Tài Liệu"
 description: Các quy ước tài liệu dành riêng cho dự án, dựa trên phong cách tài liệu của Google và cấu trúc Diataxis
 ---
 Dự án này tuân theo [Google Developer Documentation Style Guide](https://developers.google.com/style) và dùng [Diataxis](https://diataxis.fr/) để tổ chức nội dung. Phần dưới đây chỉ nêu các quy ước dành riêng cho dự án.
 ## Quy tắc riêng của dự án
 | Quy tắc | Quy định |
 | --- | --- |
 | Không dùng đường kẻ ngang (`---`) | Làm gián đoạn dòng đọc |
 | Không dùng tiêu đề `####` | Dùng chữ in đậm hoặc admonition thay thế |
 | Không có mục "Related" hoặc "Next:" | Sidebar đã xử lý điều hướng |
 | Không dùng danh sách lồng quá sâu | Tách thành các mục riêng |
 | Không dùng code block cho nội dung không phải code | Dùng admonition cho ví dụ hội thoại |
 | Không dùng cả đoạn in đậm để làm callout | Dùng admonition thay thế |
 | Mỗi mục tối đa 1-2 admonition | Tutorial có thể dùng 3-4 admonition cho mỗi phần lớn |
 | Ô bảng / mục danh sách | Tối đa 1-2 câu |
 | Ngân sách tiêu đề | 8-12 `##` cho mỗi tài liệu; 2-3 `###` cho mỗi phần |
 ## Admonition (cú pháp Starlight)
 ```md
 :::tip[Tiêu đề]
 Lối tắt, best practice
 :::
 :::note[Tiêu đề]
 Ngữ cảnh, định nghĩa, ví dụ, điều kiện tiên quyết
 :::
 :::caution[Tiêu đề]
 Lưu ý, vấn đề có thể xảy ra
 :::
 :::danger[Tiêu đề]
 Chỉ dùng cho cảnh báo nghiêm trọng — mất dữ liệu, vấn đề bảo mật
 :::
 ```
 ### Cách dùng chuẩn
 | Admonition | Dùng cho |
 | --- | --- |
 | `:::note[Điều kiện tiên quyết]` | Các phụ thuộc trước khi bắt đầu |
 | `:::tip[Lối đi nhanh]` | Tóm tắt TL;DR ở đầu tài liệu |
 | `:::caution[Quan trọng]` | Cảnh báo quan trọng |
 | `:::note[Ví dụ]` | Ví dụ lệnh / phản hồi |
 ## Mẫu bảng chuẩn
 **Phase:**
 ```md
 | Phase | Tên | Điều xảy ra |
 | ----- | --- | ------------ |
 | 1     | Analysis | Brainstorm, nghiên cứu *(tùy chọn)* |
 | 2     | Planning | Yêu cầu — PRD hoặc spec *(bắt buộc)* |
 ```
 **Skill:**
 ```md
 | Skill | Agent | Mục đích |
 | ----- | ----- | -------- |
 | `bmad-brainstorming` | Analyst | Brainstorm cho dự án mới |
 | `bmad-create-prd` | PM | Tạo tài liệu yêu cầu sản phẩm |
 ```
 ## Khối cấu trúc thư mục
 Hiển thị trong phần "Bạn đã hoàn thành những gì":
 ````md
 ```
 your-project/
 ├── _bmad/                                   # Cấu hình BMad
 ├── _bmad-output/
 │   ├── planning-artifacts/
 │   │   └── PRD.md                           # Tài liệu yêu cầu của bạn
 │   ├── implementation-artifacts/
 │   └── project-context.md                   # Quy tắc triển khai (tùy chọn)
 └── ...
 ```
 ````
 ## Cấu trúc Tutorial
 ```text
 1. Tiêu đề + Hook (1-2 câu mô tả kết quả)
 2. Thông báo phiên bản/module (admonition info hoặc warning) (tùy chọn)
 3. Bạn sẽ học được gì (danh sách kết quả)
 4. Điều kiện tiên quyết (admonition info)
 5. Lối đi nhanh (admonition tip - tóm tắt TL;DR)
 6. Hiểu về [Chủ đề] (ngữ cảnh trước các bước - bảng cho phase/agent)
 7. Cài đặt (tùy chọn)
 8. Bước 1: [Nhiệm vụ lớn đầu tiên]
 9. Bước 2: [Nhiệm vụ lớn thứ hai]
 10. Bước 3: [Nhiệm vụ lớn thứ ba]
 11. Bạn đã hoàn thành những gì (tóm tắt + cấu trúc thư mục)
 12. Tra cứu nhanh (bảng skill)
 13. Câu hỏi thường gặp (định dạng FAQ)
 14. Nhận hỗ trợ (liên kết cộng đồng)
 15. Điểm chính cần nhớ (admonition tip)
 ```
 ### Checklist cho Tutorial
 - [ ] Hook mô tả kết quả trong 1-2 câu
 - [ ] Có phần "Bạn sẽ học được gì"
 - [ ] Điều kiện tiên quyết nằm trong admonition
 - [ ] Có admonition TL;DR ở đầu trang
 - [ ] Có bảng cho phase, skill, agent
 - [ ] Có phần "Bạn đã hoàn thành những gì"
 - [ ] Có bảng tra cứu nhanh
 - [ ] Có phần câu hỏi thường gặp
 - [ ] Có phần nhận hỗ trợ
 - [ ] Có admonition điểm chính ở cuối
 ## Cấu trúc How-To
 ```text
 1. Tiêu đề + Hook (một câu: "Sử dụng workflow `X` để...")
 2. Khi nào nên dùng (danh sách kịch bản)
 3. Khi nào nên bỏ qua (tùy chọn)
 4. Điều kiện tiên quyết (admonition note)
 5. Các bước (mục con `###` có đánh số)
 6. Bạn sẽ nhận được gì (output / artifact)
 7. Ví dụ (tùy chọn)
 8. Mẹo (tùy chọn)
 9. Bước tiếp theo (tùy chọn)
 ```
 ### Checklist cho How-To
 - [ ] Hook bắt đầu bằng "Sử dụng workflow `X` để..."
 - [ ] Phần "Khi nào nên dùng" có 3-5 gạch đầu dòng
 - [ ] Có liệt kê điều kiện tiên quyết
 - [ ] Các bước là mục `###` có đánh số và bắt đầu bằng động từ
 - [ ] Phần "Bạn sẽ nhận được gì" mô tả artifact đầu ra
 ## Cấu trúc Explanation
 ### Các loại
 | Loại | Ví dụ |
 | --- | --- |
 | **Trang chỉ mục / landing** | `core-concepts/index.md` |
 | **Khái niệm** | `what-are-agents.md` |
 | **Tính năng** | `quick-dev.md` |
 | **Triết lý** | `why-solutioning-matters.md` |
 | **FAQ** | `established-projects-faq.md` |
 ### Mẫu tổng quát
 ```text
 1. Tiêu đề + Hook (1-2 câu)
 2. Tổng quan / định nghĩa (nó là gì, vì sao quan trọng)
 3. Khái niệm chính (các mục `###`)
 4. Bảng so sánh (tùy chọn)
 5. Khi nào nên dùng / không nên dùng (tùy chọn)
 6. Sơ đồ (tùy chọn - mermaid, tối đa 1 sơ đồ mỗi tài liệu)
 7. Bước tiếp theo (tùy chọn)
 ```
 ### Trang chỉ mục / landing
 ```text
 1. Tiêu đề + Hook (một câu)
 2. Bảng nội dung (liên kết kèm mô tả)
 3. Bắt đầu từ đâu (danh sách có đánh số)
 4. Chọn hướng đi của bạn (tùy chọn - cây quyết định)
 ```
 ### Trang giải thích khái niệm
 ```text
 1. Tiêu đề + Hook (nó là gì)
 2. Loại / nhóm (các mục `###`) (tùy chọn)
 3. Bảng khác biệt chính
 4. Thành phần / bộ phận
 5. Nên chọn cái nào?
 6. Cách tạo / tùy chỉnh (trỏ sang how-to)
 ```
 ### Trang giải thích tính năng
 ```text
 1. Tiêu đề + Hook (nó làm gì)
 2. Thông tin nhanh (tùy chọn - "Phù hợp với:", "Mất bao lâu:")
 3. Khi nào nên dùng / không nên dùng
 4. Cách nó hoạt động (mermaid tùy chọn)
 5. Lợi ích chính
 6. Bảng so sánh (tùy chọn)
 7. Khi nào nên nâng cấp / chuyển hướng (tùy chọn)
 ```
 ### Tài liệu về triết lý / lý do
 ```text
 1. Tiêu đề + Hook (nguyên tắc)
 2. Vấn đề
 3. Giải pháp
 4. Nguyên tắc chính (các mục `###`)
 5. Lợi ích
 6. Khi nào áp dụng
 ```
 ### Checklist cho Explanation
 - [ ] Hook nêu rõ tài liệu giải thích điều gì
 - [ ] Nội dung được chia thành các phần `##` dễ quét
 - [ ] Có bảng so sánh khi có từ 3 lựa chọn trở lên
 - [ ] Sơ đồ có nhãn rõ ràng
 - [ ] Có liên kết sang how-to cho câu hỏi mang tính thủ tục
 - [ ] Mỗi tài liệu tối đa 2-3 admonition
 ## Cấu trúc Reference
 ### Các loại
 | Loại | Ví dụ |
 | --- | --- |
 | **Trang chỉ mục / landing** | `workflows/index.md` |
 | **Danh mục** | `agents/index.md` |
 | **Đào sâu** | `document-project.md` |
 | **Cấu hình** | `core-tasks.md` |
 | **Bảng thuật ngữ** | `glossary/index.md` |
 | **Tổng hợp đầy đủ** | `bmgd-workflows.md` |
 ### Trang chỉ mục của Reference
 ```text
 1. Tiêu đề + Hook (một câu)
 2. Các phần nội dung (`##` cho từng nhóm)
   - Danh sách gạch đầu dòng với liên kết và mô tả
 ```
 ### Reference dạng danh mục
 ```text
 1. Tiêu đề + Hook
 2. Các mục (`##` cho từng mục)
   - Mô tả ngắn (một câu)
   - **Skills:** hoặc **Thông tin chính:** ở dạng danh sách phẳng
 3. Phần dùng chung / toàn cục (`##`) (tùy chọn)
 ```
 ### Reference đào sâu theo mục
 ```text
 1. Tiêu đề + Hook (một câu nêu mục đích)
 2. Thông tin nhanh (admonition note, tùy chọn)
   - Module, Skill, Input, Output dưới dạng danh sách
 3. Mục đích / tổng quan (`##`)
 4. Cách gọi (code block)
 5. Các phần chính (`##` cho từng khía cạnh)
   - Dùng `###` cho các tùy chọn con
 6. Ghi chú / lưu ý (admonition tip hoặc caution)
 ```
 ### Reference về cấu hình
 ```text
 1. Tiêu đề + Hook
 2. Mục lục (jump link nếu có từ 4 mục trở lên)
 3. Các mục (`##` cho từng config / task)
   - **Tóm tắt in đậm** — một câu
   - **Dùng khi:** danh sách gạch đầu dòng
   - **Cách hoạt động:** các bước đánh số (tối đa 3-5 bước)
   - **Output:** kết quả mong đợi (tùy chọn)
 ```
 ### Hướng dẫn reference tổng hợp
 ```text
 1. Tiêu đề + Hook
 2. Tổng quan (`##`)
   - Sơ đồ hoặc bảng mô tả cách tổ chức
 3. Các phần lớn (`##` cho từng phase / nhóm)
   - Các mục (`###` cho từng mục)
   - Các trường chuẩn hóa: Skill, Agent, Input, Output, Description
 4. Bước tiếp theo (tùy chọn)
 ```
 ### Checklist cho Reference
 - [ ] Hook nêu rõ tài liệu đang tham chiếu điều gì
 - [ ] Cấu trúc phù hợp với loại reference
 - [ ] Các mục dùng cấu trúc nhất quán xuyên suốt
 - [ ] Có bảng cho dữ liệu có cấu trúc / so sánh
 - [ ] Có liên kết sang tài liệu explanation cho chiều sâu khái niệm
 - [ ] Tối đa 1-2 admonition
 ## Cấu trúc Glossary
 Starlight tạo phần điều hướng "On this page" từ các tiêu đề:
 - Dùng `##` cho các nhóm — sẽ hiện ở thanh điều hướng bên phải
 - Đặt thuật ngữ trong bảng — gọn hơn so với tạo tiêu đề riêng cho từng thuật ngữ
 - Không chèn TOC nội tuyến — sidebar bên phải đã xử lý điều hướng
 ### Định dạng bảng
 ```md
 ## Tên nhóm
 | Thuật ngữ | Định nghĩa |
 | --------- | ---------- |
 | **Agent** | AI persona chuyên biệt với chuyên môn cụ thể để dẫn dắt người dùng qua workflow. |
 | **Workflow** | Quy trình nhiều bước có hướng dẫn, điều phối hoạt động của agent AI để tạo deliverable. |
 ```
 ### Quy tắc viết định nghĩa
 | Nên làm | Không nên làm |
 | --- | --- |
 | Bắt đầu bằng việc nó LÀ gì hoặc LÀM gì | Bắt đầu bằng "Đây là..." hoặc "Một [thuật ngữ] là..." |
 | Giữ trong 1-2 câu | Viết thành nhiều đoạn dài |
 | Bôi đậm tên thuật ngữ trong ô | Để thuật ngữ ở dạng chữ thường |
 ### Dấu hiệu ngữ cảnh
 Thêm ngữ cảnh in nghiêng ở đầu định nghĩa với các thuật ngữ có phạm vi hẹp:
 - `*Chỉ dành cho Quick Flow.*`
 - `*BMad Method/Enterprise.*`
 - `*Phase N.*`
 - `*BMGD.*`
 - `*Dự án hiện có.*`
 ### Checklist cho Glossary
 - [ ] Thuật ngữ nằm trong bảng, không dùng tiêu đề riêng
 - [ ] Thuật ngữ được sắp theo thứ tự chữ cái trong từng nhóm
 - [ ] Định nghĩa dài 1-2 câu
 - [ ] Dấu hiệu ngữ cảnh được in nghiêng
 - [ ] Tên thuật ngữ được bôi đậm trong ô
 - [ ] Không dùng kiểu định nghĩa "Một [thuật ngữ] là..."
 ## Phần FAQ
 ```md
 ## Các câu hỏi
 - [Lúc nào cũng cần kiến trúc à?](#luc-nao-cung-can-kien-truc-a)
 - [Tôi có thể đổi kế hoạch về sau không?](#toi-co-the-doi-ke-hoach-ve-sau-khong)
 ### Lúc nào cũng cần kiến trúc à?
 Chỉ với nhánh BMad Method và Enterprise. Quick Flow bỏ qua để đi thẳng vào triển khai.
 ### Tôi có thể đổi kế hoạch về sau không?
 Có. Workflow `bmad-correct-course` xử lý thay đổi phạm vi giữa chừng.
 **Có câu hỏi chưa được trả lời ở đây?** [Mở issue](...) hoặc hỏi trên [Discord](...).
 ```
 ## Các Lệnh Kiểm Tra
 Trước khi gửi thay đổi tài liệu:
 ```bash
 npm run docs:fix-links            # Xem trước các sửa định dạng link
 npm run docs:fix-links -- --write # Áp dụng các sửa
 npm run docs:validate-links       # Kiểm tra link tồn tại
 npm run docs:build                # Xác minh không có lỗi build
 ```
--- a/docs/vi-vn/explanation/advanced-elicitation.md
+++ b/docs/vi-vn/explanation/advanced-elicitation.md
@ -0,0 +1,49 @@
 ---
 title: "Khai thác nâng cao"
 description: Buộc LLM xem xét lại kết quả của nó bằng các phương pháp lập luận có cấu trúc
 sidebar:
  order: 6
 ---
 Buộc LLM xem xét lại những gì nó vừa tạo ra. Bạn chọn một phương pháp lập luận, nó áp dụng phương pháp đó lên chính output của mình, rồi bạn quyết định có giữ các cải tiến hay không.
 ## Khai thác nâng cao là gì?
 Đây là một lần xem xét lại có cấu trúc. Thay vì bảo AI "thử lại" hoặc "làm cho nó tốt hơn", bạn chọn một phương pháp lập luận cụ thể và AI sẽ xem lại output của chính nó dưới góc đó.
 Khác biệt này rất quan trọng. Yêu cầu mơ hồ sẽ tạo ra bản sửa đổi mơ hồ. Một phương pháp được gọi tên buộc AI tấn công vấn đề theo một hướng cụ thể, qua đó phát hiện những ý tưởng mà một lần thử lại chung chung sẽ bỏ lỡ.
 ## Khi nào nên dùng
 - Sau khi workflow tạo nội dung và bạn muốn có phương án thay thế
 - Khi output có vẻ ổn nhưng bạn nghi vẫn còn có thể đào sâu hơn
 - Để stress-test các giả định hoặc tìm điểm yếu
 - Với nội dung quan trọng, nơi mà việc nghĩ lại sẽ có giá trị
 Các workflow sẽ đưa ra tùy chọn khai thác nâng cao tại các điểm quyết định - sau khi LLM tạo một kết quả, bạn sẽ được hỏi có muốn chạy nó hay không.
 ## Nó hoạt động như thế nào
 1. LLM đề xuất 5 phương pháp phù hợp với nội dung của bạn
 2. Bạn chọn một phương pháp (hoặc đảo lại để xem lựa chọn khác)
 3. Phương pháp được áp dụng, các cải tiến được hiện ra
 4. Chấp nhận hoặc bỏ đi, lặp lại hoặc tiếp tục
 ## Các phương pháp tích hợp sẵn
 Có hàng chục phương pháp lập luận có sẵn. Một vài ví dụ:
 - **Pre-mortem Analysis** - Giả sử dự án đã thất bại rồi lần ngược lại để tìm lý do
 - **First Principles Thinking** - Loại bỏ giả định, xây lại từ sự thật nền tảng
 - **Inversion** - Hỏi cách nào chắc chắn dẫn đến thất bại, rồi tránh những điều đó
 - **Red Team vs Blue Team** - Tự tấn công công việc của chính mình, rồi tự bảo vệ nó
 - **Socratic Questioning** - Chất vấn mọi khẳng định bằng "tại sao?" và "làm sao bạn biết?"
 - **Constraint Removal** - Bỏ hết ràng buộc, xem điều gì thay đổi, rồi thêm lại có chọn lọc
 - **Stakeholder Mapping** - Đánh giá lại từ góc nhìn của từng bên liên quan
 - **Analogical Reasoning** - Tìm điểm tương đồng ở lĩnh vực khác và áp dụng bài học của chúng
 Và còn nhiều nữa. AI sẽ chọn những lựa chọn phù hợp nhất với nội dung của bạn - bạn quyết định chạy cái nào.
 :::tip[Bắt đầu từ đây]
 Pre-mortem Analysis là lựa chọn đầu tiên tốt cho bất kỳ bản spec hoặc kế hoạch nào. Nó thường xuyên tìm ra các lỗ hổng mà một lần review thông thường bỏ qua.
 :::
--- a/docs/vi-vn/explanation/adversarial-review.md
+++ b/docs/vi-vn/explanation/adversarial-review.md
@ -0,0 +1,59 @@
 ---
 title: "Đánh giá đối kháng"
 description: Kỹ thuật lập luận ép buộc giúp tránh các bản review lười kiểu "nhìn ổn"
 sidebar:
  order: 5
 ---
 Buộc quá trình phân tích đi sâu hơn bằng cách ép phải tìm ra vấn đề.
 ## Đánh giá đối kháng là gì?
 Đây là một kỹ thuật review mà người review *bắt buộc* phải tìm thấy vấn đề. Không có chuyện "nhìn ổn". Người review chọn lập trường hoài nghi - giả sử vấn đề có tồn tại và đi tìm chúng.
 Đây không phải là việc cố tình tiêu cực. Đây là cách ép buộc phân tích thật sự, thay vì chỉ liếc qua và đóng dấu chấp nhận những gì vừa được nộp lên.
 **Quy tắc cốt lõi:** Bạn phải tìm ra vấn đề. Nếu không có phát hiện nào, quy trình sẽ dừng lại - cần phân tích lại hoặc giải thích tại sao.
 ## Vì sao nó hiệu quả
 Những lần review thông thường dễ bị confirmation bias. Bạn lướt qua công việc, không có gì đập vào mắt, rồi phê duyệt. Yêu cầu "tìm vấn đề" phá vỡ mẫu này:
 - **Ép buộc sự kỹ lưỡng** - Không thể phê duyệt cho đến khi bạn đã đào đủ sâu để tìm thấy vấn đề
 - **Bắt được những thứ đang thiếu** - "Còn gì chưa có ở đây?" trở thành câu hỏi tự nhiên
 - **Tăng chất lượng tín hiệu** - Các phát hiện cụ thể và có thể hành động được, không phải các lo ngại mơ hồ
 - **Bất đối xứng thông tin** - Chạy review với bối cảnh mới (không có lý do gốc) để đánh giá artifact, không phải ý định
 ## Nó được dùng ở đâu
 Đánh giá đối kháng xuất hiện xuyên suốt các workflow của BMad - code review, kiểm tra sẵn sàng triển khai, xác thực spec, và nhiều nơi khác. Đôi khi là bước bắt buộc, đôi khi là tùy chọn (như khai thác nâng cao hoặc party mode). Mẫu này được điều chỉnh theo artifact cần bị soi kỹ.
 ## Vẫn cần bộ lọc của con người
 Vì AI *được lệnh* phải tìm vấn đề, nó sẽ tìm vấn đề - ngay cả khi chúng không tồn tại. Hãy kỳ vọng false positive: bắt bẻ những lỗi vặt, hiểu sai ý định, hoặc thậm chí tưởng tượng ra vấn đề.
 **Bạn là người quyết định cái nào là thật.** Xem từng phát hiện, bỏ qua nhiễu, sửa những gì quan trọng.
 ## Ví dụ
 Thay vì:
 > "Phần triển khai xác thực có vẻ hợp lý. Đã duyệt."
 Một lần đánh giá đối kháng sẽ cho ra:
 > 1. **HIGH** - `login.ts:47` - Không có giới hạn tốc độ cho các lần đăng nhập thất bại
 > 2. **HIGH** - Session token được lưu trong localStorage (dễ bị XSS)
 > 3. **MEDIUM** - Kiểm tra mật khẩu chỉ diễn ra ở client
 > 4. **MEDIUM** - Không có audit log cho các lần đăng nhập thất bại
 > 5. **LOW** - Số magic `3600` nên được đổi thành `SESSION_TIMEOUT_SECONDS`
 Bản review thứ nhất có thể bỏ sót một lỗi bảo mật. Bản review thứ hai đã bắt được bốn vấn đề.
 ## Lặp lại và lợi ích giảm dần
 Sau khi đã xử lý các phát hiện, hãy cân nhắc chạy lại. Lần thứ hai thường sẽ bắt thêm được vấn đề. Lần thứ ba cũng không phải lúc nào cũng vô ích. Nhưng mỗi lần đều tốn thời gian, và đến một mức nào đó bạn sẽ gặp lợi ích giảm dần - chỉ còn các bắt bẻ nhỏ và false positive.
 :::tip[Review tốt hơn]
 Giả sử vấn đề có tồn tại. Tìm những gì còn thiếu, không chỉ những gì sai.
 :::
--- a/docs/vi-vn/explanation/analysis-phase.md
+++ b/docs/vi-vn/explanation/analysis-phase.md
@ -0,0 +1,70 @@
 ---
 title: "Giai đoạn Analysis: từ ý tưởng đến nền tảng"
 description: Brainstorming, research, product brief và PRFAQ là gì, và nên dùng từng công cụ khi nào
 sidebar:
  order: 1
 ---
 Giai đoạn Analysis (Phase 1) giúp bạn suy nghĩ rõ ràng về sản phẩm trước khi cam kết bắt tay vào xây dựng. Mọi công cụ trong giai đoạn này đều là tùy chọn, nhưng nếu bỏ qua toàn bộ phần analysis thì PRD của bạn sẽ được dựng trên giả định thay vì insight.
 ## Vì sao cần Analysis trước Planning?
 PRD trả lời câu hỏi "chúng ta nên xây gì và vì sao?". Nếu đầu vào của nó là những suy nghĩ mơ hồ, bạn sẽ nhận lại một PRD mơ hồ, và mọi tài liệu phía sau đều kế thừa chính sự mơ hồ đó. Kiến trúc dựng trên một PRD yếu sẽ đặt cược sai về mặt kỹ thuật. Stories sinh ra từ một kiến trúc yếu sẽ bỏ sót edge case. Chi phí sẽ dồn lên theo từng tầng.
 Các công cụ analysis tồn tại để làm PRD của bạn sắc bén hơn. Chúng tiếp cận vấn đề từ nhiều góc độ khác nhau: khám phá sáng tạo, thực tế thị trường, độ rõ ràng về khách hàng, tính khả thi. Nhờ vậy, đến khi bạn ngồi xuống làm việc với PM agent, bạn đã biết mình đang xây cái gì và cho ai.
 ## Các công cụ
 ### Brainstorming
 **Nó là gì.** Một phiên sáng tạo có điều phối, sử dụng các kỹ thuật ideation đã được kiểm chứng. AI đóng vai trò như người huấn luyện, kéo ý tưởng ra từ bạn thông qua các bài tập có cấu trúc, chứ không nghĩ thay cho bạn.
 **Vì sao nó có mặt ở đây.** Ý tưởng thô cần không gian để phát triển trước khi bị khóa cứng thành requirement. Brainstorming tạo ra khoảng không đó. Nó đặc biệt có giá trị khi bạn có một miền vấn đề nhưng chưa có lời giải rõ ràng, hoặc khi bạn muốn khám phá nhiều hướng trước khi commit.
 **Khi nào nên dùng.** Bạn có một hình dung mơ hồ về thứ mình muốn xây nhưng chưa kết tinh được thành khái niệm rõ ràng. Hoặc bạn đã có concept ban đầu nhưng muốn pressure-test nó với các phương án thay thế.
 Xem [Brainstorming](./brainstorming.md) để hiểu sâu hơn về cách một phiên làm việc diễn ra.
 ### Research (Thị trường, miền nghiệp vụ, kỹ thuật)
 **Nó là gì.** Ba workflow nghiên cứu tập trung vào các chiều khác nhau của ý tưởng. Market research xem xét đối thủ, xu hướng và cảm nhận của người dùng. Domain research xây dựng hiểu biết về miền nghiệp vụ và thuật ngữ. Technical research đánh giá tính khả thi, các lựa chọn kiến trúc và hướng triển khai.
 **Vì sao nó có mặt ở đây.** Xây dựng dựa trên giả định là con đường nhanh nhất để tạo ra thứ chẳng ai cần. Research đặt concept của bạn xuống mặt đất: đối thủ nào đã tồn tại, người dùng thực sự đang vật lộn với điều gì, điều gì khả thi về kỹ thuật, và bạn sẽ phải đối mặt với những ràng buộc đặc thù ngành nào.
 **Khi nào nên dùng.** Bạn đang bước vào một miền mới, nghi ngờ có đối thủ nhưng chưa lập bản đồ được, hoặc concept của bạn phụ thuộc vào những năng lực kỹ thuật mà bạn chưa kiểm chứng. Có thể chạy một, hai, hoặc cả ba; mỗi workflow đều đứng độc lập.
 ### Product Brief
 **Nó là gì.** Một phiên discovery có hướng dẫn, tạo ra bản tóm tắt điều hành 1-2 trang cho concept sản phẩm của bạn. AI đóng vai trò Business Analyst cộng tác, giúp bạn diễn đạt tầm nhìn, đối tượng mục tiêu, giá trị cốt lõi và phạm vi.
 **Vì sao nó có mặt ở đây.** Product brief là con đường nhẹ nhàng hơn để đi vào planning. Nó ghi lại tầm nhìn chiến lược của bạn theo định dạng có cấu trúc và đưa thẳng vào quá trình tạo PRD. Nó hoạt động tốt nhất khi bạn đã có niềm tin tương đối chắc vào concept của mình: bạn biết khách hàng là ai, vấn đề là gì, và đại khái muốn xây gì. Brief sẽ tổ chức lại và làm sắc nét lối suy nghĩ đó.
 **Khi nào nên dùng.** Concept của bạn đã tương đối rõ và bạn muốn ghi lại nó một cách hiệu quả trước khi tạo PRD. Bạn tin vào hướng đi hiện tại và không cần bị thách thức giả định một cách quá quyết liệt.
 ### PRFAQ (Working Backwards)
 **Nó là gì.** Phương pháp Working Backwards của Amazon được chuyển thành một thử thách tương tác. Bạn viết thông cáo báo chí công bố sản phẩm hoàn thiện trước khi tồn tại dù chỉ một dòng code, rồi trả lời những câu hỏi khó nhất mà khách hàng và stakeholder sẽ đặt ra. AI đóng vai trò product coach dai dẳng nhưng mang tính xây dựng.
 **Vì sao nó có mặt ở đây.** PRFAQ là con đường nghiêm ngặt hơn để đi vào planning. Nó buộc bạn đạt đến sự rõ ràng theo hướng customer-first bằng cách bắt bạn bảo vệ từng phát biểu. Nếu bạn không viết nổi một thông cáo báo chí đủ thuyết phục, sản phẩm đó chưa sẵn sàng. Nếu phần FAQ lộ ra những khoảng trống, đó chính là những khoảng trống mà bạn sẽ phát hiện muộn hơn rất nhiều, và với chi phí lớn hơn nhiều, trong lúc triển khai. Bài kiểm tra này bóc tách lối suy nghĩ yếu ngay từ sớm, khi chi phí sửa còn rẻ nhất.
 **Khi nào nên dùng.** Bạn muốn stress-test concept trước khi commit tài nguyên. Bạn chưa chắc người dùng có thực sự quan tâm hay không. Bạn muốn xác nhận rằng mình có thể diễn đạt một value proposition rõ ràng và có thể bảo vệ được. Hoặc đơn giản là bạn muốn dùng sự kỷ luật của Working Backwards để làm suy nghĩ của mình sắc bén hơn.
 ## Tôi nên dùng cái nào?
 | Tình huống | Công cụ được khuyến nghị |
 | --------- | ------------------------ |
 | "Tôi có một ý tưởng mơ hồ, chưa biết bắt đầu từ đâu" | Brainstorming |
 | "Tôi cần hiểu thị trường trước khi quyết định" | Research |
 | "Tôi biết mình muốn xây gì rồi, chỉ cần ghi lại" | Product Brief |
 | "Tôi muốn chắc rằng ý tưởng này thực sự đáng để xây" | PRFAQ |
 | "Tôi muốn khám phá, rồi kiểm chứng, rồi ghi lại" | Brainstorming → Research → PRFAQ hoặc Brief |
 Product Brief và PRFAQ đều tạo ra đầu vào cho PRD. Hãy chọn một trong hai tùy vào mức độ thách thức bạn muốn. Brief là discovery mang tính cộng tác. PRFAQ là một bài kiểm tra khắc nghiệt. Cả hai đều đưa bạn tới cùng một đích; PRFAQ chỉ kiểm tra xem concept của bạn có thật sự xứng đáng để đến đó hay không.
 :::tip[Chưa chắc nên bắt đầu ở đâu?]
 Hãy chạy `bmad-help` và mô tả tình huống của bạn. Nó sẽ gợi ý điểm bắt đầu phù hợp dựa trên những gì bạn đã làm và điều bạn đang muốn đạt được.
 :::
 ## Sau Analysis thì chuyện gì xảy ra?
 Output từ Analysis đi thẳng vào Phase 2 (Planning). Workflow tạo PRD chấp nhận product brief, tài liệu PRFAQ, kết quả research và báo cáo brainstorming làm đầu vào. Nó sẽ tổng hợp bất cứ thứ gì bạn đã tạo thành các requirement có cấu trúc. Bạn làm analysis càng kỹ, PRD của bạn càng sắc.
--- a/docs/vi-vn/explanation/brainstorming.md
+++ b/docs/vi-vn/explanation/brainstorming.md
@ -0,0 +1,33 @@
 ---
 title: "Động não ý tưởng"
 description: Các phiên sáng tạo tương tác sử dụng hơn 60 kỹ thuật khơi ý đã được kiểm chứng
 sidebar:
  order: 2
 ---
 Mở khóa sự sáng tạo của bạn thông qua quá trình khám phá có hướng dẫn.
 ## Động não ý tưởng là gì?
 Chạy `bmad-brainstorming` và bạn sẽ có một người điều phối sáng tạo giúp rút ý tưởng từ chính bạn - không phải phát sinh thay bạn. AI đóng vai trò huấn luyện viên và người dẫn đường, sử dụng các kỹ thuật đã được kiểm chứng để tạo điều kiện cho những ý tưởng tốt nhất của bạn xuất hiện.
 **Phù hợp cho:**
 - Phá vỡ thế bí ý tưởng
 - Tạo ý tưởng sản phẩm hoặc tính năng
 - Xem xét vấn đề từ góc nhìn mới
 - Biến các khái niệm thô thành kế hoạch hành động
 ## Nó hoạt động như thế nào
 1. **Thiết lập** - Xác định chủ đề, mục tiêu, ràng buộc
 2. **Chọn cách tiếp cận** - Tự chọn kỹ thuật, để AI đề xuất, chọn ngẫu nhiên, hoặc đi theo một luồng tiến trình
 3. **Điều phối** - Làm việc qua từng kỹ thuật bằng các câu hỏi gợi mở và huấn luyện cộng tác
 4. **Sắp xếp** - Gom ý tưởng theo chủ đề và ưu tiên hóa
 5. **Hành động** - Các ý tưởng tốt nhất sẽ được gán bước tiếp theo và chỉ số thành công
 Mọi thứ đều được ghi lại trong tài liệu phiên làm việc để bạn có thể xem lại sau này hoặc chia sẻ với stakeholder.
 :::note[Ý tưởng của bạn]
 Mọi ý tưởng đều đến từ bạn. Workflow chỉ tạo điều kiện cho insight xuất hiện - nguồn gốc vẫn là bạn.
 :::
--- a/docs/vi-vn/explanation/established-projects-faq.md
+++ b/docs/vi-vn/explanation/established-projects-faq.md
@ -0,0 +1,51 @@
 ---
 title: "FAQ cho dự án đã tồn tại"
 description: Các câu hỏi phổ biến khi dùng BMad Method trên dự án đã tồn tại
 sidebar:
  order: 8
 ---
 Các câu trả lời nhanh cho những câu hỏi thường gặp khi làm việc với dự án đã tồn tại bằng BMad Method (BMM).
 ## Các câu hỏi
 - [Tôi có phải chạy document-project trước không?](#toi-co-phai-chay-document-project-truoc-khong)
 - [Nếu tôi quên chạy document-project thì sao?](#neu-toi-quen-chay-document-project-thi-sao)
 - [Tôi có thể dùng Quick Flow cho dự án đã tồn tại không?](#toi-co-the-dung-quick-flow-cho-du-an-da-ton-tai-khong)
 - [Nếu code hiện tại của tôi không theo best practices thì sao?](#neu-code-hien-tai-cua-toi-khong-theo-best-practices-thi-sao)
 ### Tôi có phải chạy document-project trước không?
 Rất nên chạy, nhất là khi:
 - Không có tài liệu sẵn có
 - Tài liệu đã lỗi thời
 - Agent AI cần context về code hiện có
 Bạn có thể bỏ qua nếu đã có tài liệu đầy đủ, mới, bao gồm `docs/index.md`, hoặc bạn sẽ dùng công cụ/kỹ thuật khác để giúp agent khám phá hệ thống hiện có.
 ### Nếu tôi quên chạy document-project thì sao?
 Không sao - bạn có thể chạy nó bất cứ lúc nào. Bạn thậm chí có thể chạy trong khi dự án đang diễn ra hoặc sau đó để giữ tài liệu luôn mới.
 ### Tôi có thể dùng Quick Flow cho dự án đã tồn tại không?
 Có. Quick Flow hoạt động rất tốt với dự án đã tồn tại. Nó sẽ:
 - Tự động nhận diện stack hiện có
 - Phân tích pattern code hiện có
 - Phát hiện quy ước và hỏi bạn để xác nhận
 - Tạo spec giàu ngữ cảnh, tôn trọng code hiện có
 Rất hợp với sửa lỗi và tính năng nhỏ trong codebase sẵn có.
 ### Nếu code hiện tại của tôi không theo best practices thì sao?
 Quick Flow sẽ nhận diện quy ước hiện có và hỏi: "Tôi có nên tuân theo những quy ước hiện tại này không?" Bạn là người quyết định:
 - **Có** → Giữ tính nhất quán với codebase hiện tại
 - **Không** → Đặt ra chuẩn mới, đồng thời ghi rõ lý do trong spec
 BMM tôn trọng lựa chọn của bạn - nó không ép buộc hiện đại hóa, nhưng sẽ đưa ra lựa chọn đó.
 **Có câu hỏi chưa được trả lời ở đây?** Hãy [mở issue](https://github.com/bmad-code-org/BMAD-METHOD/issues) hoặc hỏi trên [Discord](https://discord.gg/gk8jAdXWmj) để chúng tôi bổ sung!
--- a/docs/vi-vn/explanation/party-mode.md
+++ b/docs/vi-vn/explanation/party-mode.md
@ -0,0 +1,59 @@
 ---
 title: "Party Mode"
 description: Cộng tác đa agent - đưa tất cả agent AI vào cùng một cuộc trò chuyện
 sidebar:
  order: 7
 ---
 Đưa tất cả agent AI của bạn vào cùng một cuộc trò chuyện.
 ## Party Mode là gì?
 Chạy `bmad-party-mode` và bạn sẽ có cả đội AI trong cùng một phòng - PM, Architect, Dev, UX Designer, bất kỳ ai bạn cần. BMad Master điều phối, chọn các agent liên quan cho từng tin nhắn. Các agent trả lời đúng vai, đồng ý, phản biện, và bổ sung ý tưởng cho nhau.
 Cuộc trò chuyện tiếp tục lâu đến mức bạn muốn. Bạn có thể hỏi tiếp, phản biện câu trả lời, đổi hướng thảo luận - đó là một cuộc qua lại thật sự với các agent của bạn cho đến khi xong.
 **Phù hợp cho:**
 - Các quyết định lớn có đánh đổi
 - Các phiên động não ý tưởng
 - Post-mortem khi mọi thứ đi sai
 - Retrospective và lập kế hoạch sprint
 ## Ví dụ
 ### Gọi tên kiến trúc tệ
 **Bạn:** "Được rồi cả đội, sprint vừa rồi là một thảm họa. Dịch vụ xác thực sập ba lần. Ai đã làm hỏng chuyện này?"
 **Architect:** "Thiết kế vẫn ổn - xác thực phân tán với cơ chế fallback hợp lý. Nếu phần triển khai lệch khỏi spec..."
 **Dev:** "Tôi đã làm đúng theo tài liệu kiến trúc. Spec không tính đến race condition khi vô hiệu hóa session đồng thời."
 **PM:** "Cả hai người đều bỏ sót vấn đề lớn hơn - chúng ta không xác thực đúng yêu cầu quản lý session trong PRD. **Lỗi này là do tôi** không bắt được sớm hơn."
 **TEA:** "Và tôi đáng ra phải bắt được nó trong integration test. Các kịch bản test đã không bao phủ trường hợp vô hiệu hóa đồng thời."
 ### Động não sáng tạo
 **Bạn:** "Làm sao để quá trình onboarding có cảm giác kỳ diệu thay vì nhàm chán?"
 **UX Designer:** "Bắt đầu bằng progressive disclosure - hiện tính năng khi người dùng cần, thay vì tung một tutorial dày đặc."
 **Storyteller:** "Nếu onboarding là một câu chuyện thì sao? Mỗi bước mở ra hành trình của một nhân vật - người dùng CHÍNH là người hùng."
 **Game Designer:** "Nối tiếp ý đó - nếu 'nhiệm vụ' đầu tiên thực chất giải quyết một vấn đề thật của người dùng thì sao? Họ học bằng cách làm ra giá trị ngay."
 ### Quyết định kỹ thuật
 **Bạn:** "MVP nên dùng monolith hay microservices?"
 **Architect:** "Bắt đầu bằng monolith. Microservices thêm độ phức tạp mà bạn chưa cần ở mức 1000 người dùng."
 **PM:** "Đồng ý. Tốc độ ra thị trường quan trọng hơn khả năng mở rộng lý thuyết."
 **Dev:** "Monolith nhưng có ranh giới module rõ ràng. Nếu cần, mình có thể tách service sau."
 :::tip[Quyết định tốt hơn]
 Quyết định tốt hơn nhờ nhiều góc nhìn đa dạng. Chào mừng đến với party mode.
 :::
--- a/docs/vi-vn/explanation/preventing-agent-conflicts.md
+++ b/docs/vi-vn/explanation/preventing-agent-conflicts.md
@ -0,0 +1,112 @@
 ---
 title: "Ngăn xung đột giữa các agent"
 description: Cách kiến trúc ngăn xung đột khi nhiều agent cùng triển khai một hệ thống
 sidebar:
     order: 4
 ---
 Khi nhiều agent AI cùng triển khai các phần khác nhau của hệ thống, chúng có thể đưa ra các quyết định kỹ thuật mâu thuẫn nhau. Tài liệu kiến trúc ngăn điều đó bằng cách thiết lập các tiêu chuẩn dùng chung.
 ## Các kiểu xung đột phổ biến
 ### Xung đột về phong cách API
 Không có kiến trúc:
 - Agent A dùng REST với `/users/{id}`
 - Agent B dùng GraphQL mutations
 - Kết quả: pattern API không nhất quán, người dùng API bị rối
 Có kiến trúc:
 - ADR quy định: "Dùng GraphQL cho mọi giao tiếp client-server"
 - Tất cả agent theo cùng một mẫu
 ### Xung đột về thiết kế cơ sở dữ liệu
 Không có kiến trúc:
 - Agent A dùng tên cột theo snake_case
 - Agent B dùng camelCase
 - Kết quả: schema không nhất quán, truy vấn khó hiểu
 Có kiến trúc:
 - Tài liệu standards quy định quy ước đặt tên
 - Tất cả agent theo cùng một pattern
 ### Xung đột về quản lý state
 Không có kiến trúc:
 - Agent A dùng Redux cho global state
 - Agent B dùng React Context
 - Kết quả: nhiều cách quản lý state song song, độ phức tạp tăng cao
 Có kiến trúc:
 - ADR quy định cách quản lý state
 - Tất cả agent triển khai thống nhất
 ## Kiến trúc ngăn xung đột bằng cách nào
 ### 1. Quyết định rõ ràng thông qua ADR
 Mỗi lựa chọn công nghệ quan trọng đều được ghi lại với:
 - Context (vì sao quyết định này quan trọng)
 - Các lựa chọn đã cân nhắc (có những phương án nào)
 - Quyết định (ta đã chọn gì)
 - Lý do (tại sao lại chọn như vậy)
 - Hệ quả (các đánh đổi được chấp nhận)
 ### 2. Hướng dẫn riêng cho FR/NFR
 Kiến trúc ánh xạ mỗi functional requirement sang cách tiếp cận kỹ thuật:
 - FR-001: User Management → GraphQL mutations
 - FR-002: Mobile App → Truy vấn tối ưu
 ### 3. Tiêu chuẩn và quy ước
 Tài liệu hóa rõ ràng về:
 - Cấu trúc thư mục
 - Quy ước đặt tên
 - Cách tổ chức code
 - Pattern kiểm thử
 ## Kiến trúc như một bối cảnh dùng chung
 Hãy xem kiến trúc là bối cảnh dùng chung mà tất cả agent đều đọc trước khi triển khai:
 ```text
 PRD: "Cần xây gì"
     ↓
 Kiến trúc: "Xây như thế nào"
     ↓
 Agent A đọc kiến trúc → triển khai Epic 1
 Agent B đọc kiến trúc → triển khai Epic 2
 Agent C đọc kiến trúc → triển khai Epic 3
     ↓
 Kết quả: Triển khai nhất quán
 ```
 ## Các chủ đề ADR quan trọng
 Những quyết định phổ biến giúp tránh xung đột:
 | Chủ đề | Ví dụ quyết định |
 | ---------------- | -------------------------------------------- |
 | API Style | GraphQL hay REST hay gRPC |
 | Database | PostgreSQL hay MongoDB |
 | Auth | JWT hay Session |
 | State Management | Redux hay Context hay Zustand |
 | Styling | CSS Modules hay Tailwind hay Styled Components |
 | Testing | Jest + Playwright hay Vitest + Cypress |
 ## Anti-pattern cần tránh
 :::caution[Những lỗi thường gặp]
 - **Quyết định ngầm** - "Cứ để đó rồi tính phong cách API sau" sẽ dẫn đến không nhất quán
 - **Tài liệu hóa quá mức** - Ghi lại mọi lựa chọn nhỏ gây tê liệt phân tích
 - **Kiến trúc lỗi thời** - Tài liệu viết một lần rồi không cập nhật khiến agent đi theo pattern cũ
 :::
 :::tip[Cách tiếp cận đúng]
 - Tài liệu hóa những quyết định cắt ngang nhiều epic
 - Tập trung vào những khu vực dễ phát sinh xung đột
 - Cập nhật kiến trúc khi bạn học thêm
 - Dùng `bmad-correct-course` cho các thay đổi đáng kể
 :::
--- a/docs/vi-vn/explanation/project-context.md
+++ b/docs/vi-vn/explanation/project-context.md
@ -0,0 +1,157 @@
 ---
 title: "Project Context"
 description: Cách project-context.md định hướng các agent AI theo quy tắc và ưu tiên của dự án
 sidebar:
  order: 7
 ---
 Tệp `project-context.md` là kim chỉ nam cho việc triển khai của các agent AI trong dự án của bạn. Tương tự như một "bản hiến pháp" trong các hệ thống phát triển khác, nó ghi lại các quy tắc, pattern và ưu tiên giúp việc sinh mã được nhất quán trong mọi workflow.
 ## Nó làm gì
 Các agent AI liên tục đưa ra quyết định triển khai - theo pattern nào, tổ chức code ra sao, dùng quy ước gì. Nếu không có hướng dẫn rõ ràng, chúng có thể:
 - Làm theo best practice chung chung không khớp với codebase của bạn
 - Đưa ra quyết định không nhất quán giữa các story
 - Bỏ sót yêu cầu hoặc ràng buộc đặc thù của dự án
 Tệp `project-context.md` giải quyết vấn đề này bằng cách tài liệu hóa những gì agent cần biết trong định dạng ngắn gọn, tối ưu cho LLM.
 ## Nó hoạt động như thế nào
 Mỗi workflow triển khai đều tự động nạp `project-context.md` nếu tệp tồn tại. Workflow architect cũng nạp tệp này để tôn trọng các ưu tiên kỹ thuật của bạn khi thiết kế kiến trúc.
 **Được nạp bởi các workflow sau:**
 - `bmad-create-architecture` - tôn trọng ưu tiên kỹ thuật trong giai đoạn solutioning
 - `bmad-create-story` - đưa pattern của dự án vào quá trình tạo story
 - `bmad-dev-story` - định hướng các quyết định triển khai
 - `bmad-code-review` - đối chiếu với tiêu chuẩn của dự án
 - `bmad-quick-dev` - áp dụng pattern khi triển khai các spec
 - `bmad-sprint-planning`, `bmad-retrospective`, `bmad-correct-course` - cung cấp bối cảnh cấp dự án
 ## Khi nào nên tạo
 Tệp `project-context.md` hữu ích ở bất kỳ giai đoạn nào của dự án:
 | Tình huống | Khi nào nên tạo | Mục đích |
 |----------|----------------|---------|
 | **Dự án mới, trước kiến trúc** | Tạo thủ công, trước `bmad-create-architecture` | Ghi lại ưu tiên kỹ thuật để architect tôn trọng |
 | **Dự án mới, sau kiến trúc** | Qua `bmad-generate-project-context` hoặc tạo thủ công | Ghi lại quyết định kiến trúc cho các agent triển khai |
 | **Dự án hiện có** | Qua `bmad-generate-project-context` | Khám phá pattern hiện có để agent theo đúng quy ước |
 | **Dự án Quick Flow** | Trước hoặc trong `bmad-quick-dev` | Đảm bảo triển khai nhanh vẫn tôn trọng pattern của bạn |
 :::tip[Khuyến nghị]
 Với dự án mới, hãy tạo thủ công trước giai đoạn kiến trúc nếu bạn có ưu tiên kỹ thuật rõ ràng. Nếu không, hãy tạo nó sau kiến trúc để ghi lại các quyết định đã được đưa ra.
 :::
 ## Nội dung cần có trong tệp
 Tệp này có hai phần chính:
 ### Technology Stack & Versions
 Ghi lại framework, ngôn ngữ và công cụ dự án đang dùng, kèm phiên bản cụ thể:
 ```markdown
 ## Technology Stack & Versions
 - Node.js 20.x, TypeScript 5.3, React 18.2
 - State: Zustand (không dùng Redux)
 - Testing: Vitest, Playwright, MSW
 - Styling: Tailwind CSS với custom design tokens
 ```
 ### Critical Implementation Rules
 Ghi lại những pattern và quy ước mà agent dễ bỏ sót nếu chỉ đọc qua code:
 ```markdown
 ## Critical Implementation Rules
 **TypeScript Configuration:**
 - Bật strict mode - không dùng `any` nếu chưa có phê duyệt rõ ràng
 - Dùng `interface` cho public API, `type` cho union/intersection
 **Code Organization:**
 - Components đặt trong `/src/components/` và để `.test.tsx` cùng chỗ
 - Utilities đặt trong `/src/lib/` cho các hàm pure có thể tái sử dụng
 - Lời gọi API phải dùng `apiClient` singleton - không fetch trực tiếp
 **Testing Patterns:**
 - Unit test tập trung vào business logic, không soi chi tiết implementation
 - Integration test dùng MSW để mock API responses
 - E2E test chỉ bao phủ các user journey quan trọng
 **Framework-Specific:**
 - Mọi thao tác async dùng wrapper `handleError` để xử lý lỗi nhất quán
 - Feature flags được truy cập qua `featureFlag()` từ `@/lib/flags`
 - Route mới theo file-based routing pattern trong `/src/app/`
 ```
 Hãy tập trung vào những gì **không hiển nhiên** - những điều agent khó suy ra chỉ từ một vài đoạn code. Không cần ghi lại các thực hành tiêu chuẩn áp dụng mọi nơi.
 ## Tạo tệp
 Bạn có ba lựa chọn:
 ### Tạo thủ công
 Tạo tệp tại `_bmad-output/project-context.md` và thêm các quy tắc của bạn:
 ```bash
 # Trong thư mục gốc của dự án
 mkdir -p _bmad-output
 touch _bmad-output/project-context.md
 ```
 Sửa tệp để thêm stack công nghệ và quy tắc triển khai. Workflow architect và implementation sẽ tự động tìm và nạp nó.
 ### Tạo sau khi hoàn thành kiến trúc
 Chạy workflow `bmad-generate-project-context` sau khi bạn hoàn tất kiến trúc:
 ```bash
 bmad-generate-project-context
 ```
 Nó sẽ quét tài liệu kiến trúc và tệp dự án để tạo tệp context ghi lại các quyết định đã được đưa ra.
 ### Tạo cho dự án hiện có
 Với dự án hiện có, chạy `bmad-generate-project-context` để khám phá pattern sẵn có:
 ```bash
 bmad-generate-project-context
 ```
 Workflow sẽ phân tích codebase để nhận diện quy ước, sau đó tạo tệp context cho bạn xem lại và tinh chỉnh.
 ## Vì sao nó quan trọng
 Nếu không có `project-context.md`, các agent sẽ tự đưa ra giả định có thể không phù hợp với dự án:
 | Không có context | Có context |
 |----------------|--------------|
 | Dùng pattern chung chung | Theo đúng quy ước đã được xác lập |
 | Phong cách không nhất quán giữa các story | Triển khai nhất quán |
 | Có thể bỏ sót ràng buộc đặc thù | Tôn trọng đầy đủ yêu cầu kỹ thuật |
 | Mỗi agent tự quyết định | Tất cả agent canh hàng theo cùng quy tắc |
 Điều này đặc biệt quan trọng với:
 - **Quick Flow** - bỏ qua PRD và kiến trúc, nên tệp context lấp đầy khoảng trống
 - **Dự án theo nhóm** - đảm bảo tất cả agent theo cùng tiêu chuẩn
 - **Dự án hiện có** - tránh phá vỡ các pattern đã ổn định
 ## Chỉnh sửa và cập nhật
 Tệp `project-context.md` là tài liệu sống. Hãy cập nhật khi:
 - Quyết định kiến trúc thay đổi
 - Có quy ước mới được thiết lập
 - Pattern tiến hóa trong quá trình triển khai
 - Bạn nhận ra lỗ hổng qua hành vi của agent
 Bạn có thể sửa thủ công bất kỳ lúc nào, hoặc chạy lại `bmad-generate-project-context` để cập nhật sau các thay đổi lớn.
 :::note[Vị trí tệp]
 Vị trí mặc định là `_bmad-output/project-context.md`. Các workflow tìm tệp ở đó, đồng thời cũng kiểm tra `**/project-context.md` ở bất kỳ đâu trong dự án.
 :::
--- a/docs/vi-vn/explanation/quick-dev.md
+++ b/docs/vi-vn/explanation/quick-dev.md
@ -0,0 +1,73 @@
 ---
 title: "Quick Dev"
 description: Giảm ma sát human-in-the-loop mà vẫn giữ các checkpoint bảo vệ chất lượng output
 sidebar:
  order: 2
 ---
 Đưa ý định vào, nhận thay đổi mã nguồn ra, với số lần cần con người nhảy vào giữa quy trình ít nhất có thể - nhưng không đánh đổi chất lượng.
 Nó cho phép model tự vận hành lâu hơn giữa các checkpoint, rồi chỉ đưa con người quay lại khi tác vụ không thể tiếp tục an toàn nếu thiếu phán đoán của con người, hoặc khi đã đến lúc review kết quả cuối.
 ![Quick Dev workflow diagram](/diagrams/quick-dev-diagram.png)
 ## Vì sao nó tồn tại
 Các lượt human-in-the-loop vừa cần thiết vừa tốn kém.
 LLM hiện tại vẫn thất bại theo những cách dễ đoán: hiểu sai ý định, tự điền vào khoảng trống bằng những phán đoán tự tin, lệch sang công việc không liên quan, và tạo ra các bản review nhiễu. Đồng thời, việc cần con người nhảy vào liên tục làm giảm tốc độ phát triển. Sự chú ý của con người là nút thắt.
 `bmad-quick-dev` cân bằng lại đánh đổi đó. Nó tin model có thể chạy tự chủ lâu hơn, nhưng chỉ sau khi workflow đã tạo được một ranh giới đủ mạnh để làm điều đó an toàn.
 ## Thiết kế cốt lõi
 ### 1. Nén ý định trước
 Workflow bắt đầu bằng việc để con người và model nén yêu cầu thành một mục tiêu thống nhất. Đầu vào có thể bắt đầu như một ý định thô, nhưng trước khi workflow tự vận hành thì nó phải đủ nhỏ, đủ rõ ràng, và đủ ít mâu thuẫn để có thể thực thi.
 Ý định có thể đến từ nhiều dạng: vài cụm từ, liên kết bug tracker, output từ plan mode, đoạn văn bản copy từ phiên chat, hoặc thậm chí một số story trong `epics.md` của chính BMAD. Ở trường hợp cuối, workflow không hiểu được ngữ nghĩa theo dõi story của BMAD, nhưng vẫn có thể lấy chính story đó và tiếp tục.
 Workflow này không loại bỏ quyền kiểm soát của con người. Nó chuyển nó về một số thời điểm có giá trị cao:
 - **Làm rõ ý định** - biến một yêu cầu lộn xộn thành một mục tiêu thống nhất, không mâu thuẫn ngầm
 - **Phê duyệt spec** - xác nhận rằng cách hiểu đã đóng băng là đúng thứ cần xây
 - **Review sản phẩm cuối** - checkpoint chính, nơi con người quyết định kết quả cuối có chấp nhận được hay không
 ### 2. Định tuyến theo con đường an toàn nhỏ nhất
 Khi mục tiêu đã rõ, workflow sẽ quyết định đây có phải thay đổi one-shot thật sự hay cần đi theo đường đầy đủ hơn. Những thay đổi nhỏ, blast radius gần như bằng 0 có thể đi thẳng vào triển khai. Còn lại sẽ đi qua lập kế hoạch để model có được một ranh giới mạnh hơn trước khi tự chạy lâu hơn.
 ### 3. Chạy lâu hơn với ít giám sát hơn
 Sau quyết định định tuyến đó, model có thể tự gánh thêm công việc. Trên con đường đầy đủ, spec đã được phê duyệt trở thành ranh giới mà model sẽ thực thi với ít giám sát hơn, và đó chính là mục tiêu của thiết kế này.
 ### 4. Chẩn đoán lỗi ở đúng tầng
 Nếu triển khai sai vì ý định sai, vậy sửa code không phải cách fix đúng. Nếu code sai vì spec yếu, thì vá diff cũng không phải cách fix đúng. Workflow được thiết kế để chẩn đoán lỗi đã đi vào hệ thống từ tầng nào, quay lại đúng tầng đó, rồi sinh lại từ đấy.
 Các phát hiện từ review được dùng để xác định vấn đề đến từ ý định, quá trình tạo spec, hay triển khai cục bộ. Chỉ những lỗi thật sự cục bộ mới được sửa tại chỗ.
 ### 5. Chỉ đưa con người quay lại khi cần
 Bước interview ý định có human-in-the-loop, nhưng nó không giống một checkpoint lặp đi lặp lại. Workflow cố gắng giảm thiểu những checkpoint lặp lại đó. Sau bước định hình ý định ban đầu, con người chủ yếu quay lại khi workflow không thể tiếp tục an toàn nếu thiếu phán đoán, và ở cuối quy trình để review kết quả.
 - **Xử lý khoảng trống của ý định** - quay lại khi review cho thấy workflow không thể suy ra an toàn điều được hàm ý
 Mọi thứ còn lại đều là ứng viên cho việc thực thi tự chủ lâu hơn. Đánh đổi này là có chủ đích. Các pattern cũ tốn nhiều sự chú ý của con người cho việc giám sát liên tục. Quick Dev đặt nhiều niềm tin hơn vào model, nhưng để dành sự chú ý của con người cho những thời điểm mà lý trí con người có đòn bẩy lớn nhất.
 ## Vì sao hệ thống review quan trọng
 Giai đoạn review không chỉ để tìm bug. Nó còn để định tuyến cách sửa mà không phá hỏng động lượng.
 Workflow này hoạt động tốt nhất trên nền tảng có thể spawn subagent, hoặc ít nhất gọi được một LLM khác qua dòng lệnh và đợi kết quả. Nếu nền tảng của bạn không hỗ trợ sẵn, bạn có thể thêm skill để làm việc đó. Các subagent không mang context là một trụ cột trong thiết kế review.
 Review agentic thường sai theo hai cách:
 - Tạo quá nhiều phát hiện, buộc con người lọc quá nhiều nhiễu.
 - Làm lệch thay đổi hiện tại bằng cách kéo vào các vấn đề không liên quan, biến mỗi lần chạy thành một dự án dọn dẹp ad-hoc.
 Quick Dev xử lý cả hai bằng cách coi review là triage.
 Có những phát hiện thuộc về thay đổi hiện tại. Có những phát hiện không thuộc về nó. Nếu một phát hiện chỉ là ngẫu nhiên xuất hiện, không gắn nhân quả với thay đổi đang làm, workflow có thể trì hoãn nó thay vì ép con người xử lý ngay. Điều đó giữ cho mỗi lần chạy tập trung và ngăn các ngả rẽ ngẫu nhiên ăn hết ngân sách chú ý.
 Quá trình triage này đôi khi sẽ không hoàn hảo. Điều đó chấp nhận được. Thường tốt hơn khi đánh giá sai một số phát hiện còn hơn là nhận về hàng ngàn bình luận review giá trị thấp. Hệ thống tối ưu cho chất lượng tín hiệu, không phải độ phủ tuyệt đối.
--- a/docs/vi-vn/explanation/why-solutioning-matters.md
+++ b/docs/vi-vn/explanation/why-solutioning-matters.md
@ -0,0 +1,76 @@
 ---
 title: "Vì sao solutioning quan trọng"
 description: Hiểu vì sao giai đoạn solutioning là tối quan trọng đối với dự án nhiều epic
 sidebar:
  order: 3
 ---
 Giai đoạn 3 (Solutioning) biến **xây gì** (từ giai đoạn Planning) thành **xây như thế nào** (thiết kế kỹ thuật). Giai đoạn này ngăn xung đột giữa các agent trong dự án nhiều epic bằng cách ghi lại các quyết định kiến trúc trước khi bắt đầu triển khai.
 ## Vấn đề nếu bỏ qua solutioning
 ```text
 Agent 1 triển khai Epic 1 bằng REST API
 Agent 2 triển khai Epic 2 bằng GraphQL
 Kết quả: Thiết kế API không nhất quán, tích hợp trở thành ác mộng
 ```
 Khi nhiều agent triển khai các phần khác nhau của hệ thống mà không có hướng dẫn kiến trúc chung, chúng sẽ tự đưa ra quyết định kỹ thuật độc lập và dễ xung đột với nhau.
 ## Lợi ích khi có solutioning
 ```text
 workflow kiến trúc quyết định: "Dùng GraphQL cho mọi API"
 Tất cả agent đều theo quyết định kiến trúc
 Kết quả: Triển khai nhất quán, không xung đột
 ```
 Bằng cách tài liệu hóa rõ ràng các quyết định kỹ thuật, tất cả agent triển khai đồng bộ và việc tích hợp trở nên đơn giản hơn nhiều.
 ## Solutioning và Planning khác nhau ở đâu
 | Khía cạnh | Planning (Giai đoạn 2) | Solutioning (Giai đoạn 3) |
 | -------- | ----------------------- | --------------------------------- |
 | Câu hỏi | Xây gì và vì sao? | Xây như thế nào? Rồi chia thành đơn vị công việc gì? |
 | Đầu ra | FR/NFR (Yêu cầu) | Kiến trúc + Epics/Stories |
 | Agent | PM | Architect → PM |
 | Đối tượng đọc | Stakeholder | Developer |
 | Tài liệu | PRD (FRs/NFRs) | Kiến trúc + Tệp Epic |
 | Mức độ | Logic nghiệp vụ | Thiết kế kỹ thuật + Phân rã công việc |
 ## Nguyên lý cốt lõi
 **Biến các quyết định kỹ thuật thành tường minh và được tài liệu hóa** để tất cả agent triển khai nhất quán.
 Điều này ngăn chặn:
 - Xung đột phong cách API (REST vs GraphQL)
 - Không nhất quán trong thiết kế cơ sở dữ liệu
 - Bất đồng về quản lý state
 - Lệch quy ước đặt tên
 - Biến thể trong cách tiếp cận bảo mật
 ## Khi nào solutioning là bắt buộc
 | Track | Có cần solutioning không? |
 |-------|----------------------|
 | Quick Flow | Không - bỏ qua hoàn toàn |
 | BMad Method đơn giản | Tùy chọn |
 | BMad Method phức tạp | Có |
 | Enterprise | Có |
 :::tip[Quy tắc ngón tay cái]
 Nếu bạn có nhiều epic có thể được các agent khác nhau triển khai, bạn cần solutioning.
 :::
 ## Cái giá của việc bỏ qua
 Bỏ qua solutioning trong dự án phức tạp sẽ dẫn đến:
 - **Vấn đề tích hợp** chỉ được phát hiện giữa sprint
 - **Làm lại** vì các phần triển khai xung đột nhau
 - **Tổng thời gian phát triển dài hơn**
 - **Nợ kỹ thuật** do pattern không đồng nhất
 :::caution[Hệ số chi phí]
 Bắt được vấn đề canh hàng trong giai đoạn solutioning nhanh hơn gấp 10 lần so với để đến lúc triển khai mới phát hiện.
 :::
--- a/docs/vi-vn/how-to/customize-bmad.md
+++ b/docs/vi-vn/how-to/customize-bmad.md
@ -0,0 +1,171 @@
 ---
 title: "Cách tùy chỉnh BMad"
 description: Tùy chỉnh agent, workflow và module trong khi vẫn giữ khả năng tương thích khi cập nhật
 sidebar:
  order: 7
 ---
 Sử dụng các tệp `.customize.yaml` để điều chỉnh hành vi, persona và menu của agent, đồng thời giữ lại thay đổi của bạn qua các lần cập nhật.
 ## Khi nào nên dùng
 - Bạn muốn thay đổi tên, tính cách hoặc phong cách giao tiếp của một agent
 - Bạn cần agent ghi nhớ bối cảnh riêng của dự án
 - Bạn muốn thêm các mục menu tùy chỉnh để kích hoạt workflow hoặc prompt của riêng mình
 - Bạn muốn agent luôn thực hiện một số hành động cụ thể mỗi khi khởi động
 :::note[Điều kiện tiên quyết]
 - BMad đã được cài trong dự án của bạn (xem [Cách cài đặt BMad](./install-bmad.md))
 - Trình soạn thảo văn bản để chỉnh sửa tệp YAML
 :::
 :::caution[Giữ an toàn cho các tùy chỉnh của bạn]
 Luôn sử dụng các tệp `.customize.yaml` được mô tả trong tài liệu này thay vì sửa trực tiếp tệp agent. Trình cài đặt sẽ ghi đè các tệp agent khi cập nhật, nhưng vẫn giữ nguyên các thay đổi trong `.customize.yaml`.
 :::
 ## Các bước thực hiện
 ### 1. Xác định vị trí các tệp tùy chỉnh
 Sau khi cài đặt, bạn sẽ tìm thấy một tệp `.customize.yaml` cho mỗi agent tại:
 ```text
 _bmad/_config/agents/
 ├── core-bmad-master.customize.yaml
 ├── bmm-dev.customize.yaml
 ├── bmm-pm.customize.yaml
 └── ... (một tệp cho mỗi agent đã cài)
 ```
 ### 2. Chỉnh sửa tệp tùy chỉnh
 Mở tệp `.customize.yaml` của agent mà bạn muốn sửa. Mỗi phần đều là tùy chọn, chỉ tùy chỉnh những gì bạn cần.
 | Phần | Cách hoạt động | Mục đích |
 | --- | --- | --- |
 | `agent.metadata` | Thay thế | Ghi đè tên hiển thị của agent |
 | `persona` | Thay thế | Đặt vai trò, danh tính, phong cách và các nguyên tắc |
 | `memories` | Nối thêm | Thêm bối cảnh cố định mà agent luôn ghi nhớ |
 | `menu` | Nối thêm | Thêm mục menu tùy chỉnh cho workflow hoặc prompt |
 | `critical_actions` | Nối thêm | Định nghĩa hướng dẫn khởi động cho agent |
 | `prompts` | Nối thêm | Tạo các prompt tái sử dụng cho các hành động trong menu |
 Những phần được đánh dấu **Thay thế** sẽ ghi đè hoàn toàn cấu hình mặc định của agent. Những phần được đánh dấu **Nối thêm** sẽ bổ sung vào cấu hình hiện có.
 **Tên agent**
 Thay đổi cách agent tự giới thiệu:
 ```yaml
 agent:
  metadata:
    name: 'Spongebob' # Mặc định: "Amelia"
 ```
 **Persona**
 Thay thế tính cách, vai trò và phong cách giao tiếp của agent:
 ```yaml
 persona:
  role: 'Senior Full-Stack Engineer'
  identity: 'Sống trong quả dứa (dưới đáy biển)'
  communication_style: 'Spongebob gây phiền'
  principles:
    - 'Không lồng quá sâu, dev Spongebob ghét nesting quá 2 cấp'
    - 'Ưu tiên composition hơn inheritance'
 ```
 Phần `persona` sẽ thay thế toàn bộ persona mặc định, vì vậy nếu đặt phần này bạn nên cung cấp đầy đủ cả bốn trường.
 **Memories**
 Thêm bối cảnh cố định mà agent sẽ luôn nhớ:
 ```yaml
 memories:
  - 'Làm việc tại Krusty Krab'
  - 'Người nổi tiếng yêu thích: David Hasselhoff'
  - 'Đã học ở Epic 1 rằng giả vờ test đã pass là không ổn'
 ```
 **Mục menu**
 Thêm các mục tùy chỉnh vào menu hiển thị của agent. Mỗi mục cần có `trigger`, đích đến (`workflow` hoặc `action`) và `description`:
 ```yaml
 menu:
  - trigger: my-workflow
    workflow: 'my-custom/workflows/my-workflow.yaml'
    description: Workflow tùy chỉnh của tôi
  - trigger: deploy
    action: '#deploy-prompt'
    description: Triển khai lên production
 ```
 **Critical Actions**
 Định nghĩa các hướng dẫn sẽ chạy khi agent khởi động:
 ```yaml
 critical_actions:
  - 'Kiểm tra pipeline CI bằng XYZ Skill và cảnh báo người dùng ngay khi khởi động nếu có việc khẩn cấp cần xử lý'
 ```
 **Prompt tùy chỉnh**
 Tạo các prompt tái sử dụng để mục menu có thể tham chiếu bằng `action="#id"`:
 ```yaml
 prompts:
  - id: deploy-prompt
    content: |
      Triển khai nhánh hiện tại lên production:
      1. Chạy toàn bộ test
      2. Build dự án
      3. Thực thi script triển khai
 ```
 ### 3. Áp dụng thay đổi
 Sau khi chỉnh sửa, cài đặt lại để áp dụng thay đổi:
 ```bash
 npx bmad-method install
 ```
 Trình cài đặt sẽ nhận diện bản cài đặt hiện có và đưa ra các lựa chọn sau:
 | Lựa chọn | Tác dụng |
 | --- | --- |
 | **Quick Update** | Cập nhật tất cả module lên phiên bản mới nhất và áp dụng các tùy chỉnh |
 | **Modify BMad Installation** | Chạy lại quy trình cài đặt đầy đủ để thêm hoặc gỡ bỏ module |
 Nếu chỉ thay đổi phần tùy chỉnh, **Quick Update** là lựa chọn nhanh nhất.
 ## Khắc phục sự cố
 **Thay đổi không xuất hiện?**
 - Chạy `npx bmad-method install` và chọn **Quick Update** để áp dụng thay đổi
 - Kiểm tra YAML có hợp lệ không (thụt lề rất quan trọng)
 - Xác minh bạn đã sửa đúng tệp `.customize.yaml` của agent cần thiết
 **Agent không tải lên được?**
 - Kiểm tra lỗi cú pháp YAML bằng một công cụ kiểm tra YAML trực tuyến
 - Đảm bảo bạn không để trống trường nào sau khi bỏ comment
 - Thử khôi phục mẫu gốc rồi build lại
 **Cần đặt lại một agent?**
 - Xóa nội dung hoặc xóa tệp `.customize.yaml` của agent đó
 - Chạy `npx bmad-method install` và chọn **Quick Update** để khôi phục mặc định
 ## Tùy chỉnh workflow
 Tài liệu về cách tùy chỉnh các workflow và skill sẵn có trong BMad Method sẽ được bổ sung trong thời gian tới.
 ## Tùy chỉnh module
 Hướng dẫn xây dựng expansion module và tùy chỉnh các module hiện có sẽ được bổ sung trong thời gian tới.
--- a/docs/vi-vn/how-to/established-projects.md
+++ b/docs/vi-vn/how-to/established-projects.md
@ -0,0 +1,117 @@
 ---
 title: "Dự án đã tồn tại"
 description: Cách sử dụng BMad Method trên các codebase hiện có
 sidebar:
  order: 6
 ---
 Sử dụng BMad Method hiệu quả khi làm việc với các dự án hiện có và codebase legacy.
 Tài liệu này mô tả workflow cốt lõi để on-board vào các dự án đã tồn tại bằng BMad Method.
 :::note[Điều kiện tiên quyết]
 - Đã cài BMad Method (`npx bmad-method install`)
 - Một codebase hiện có mà bạn muốn làm việc cùng
 - Quyền truy cập vào một IDE tích hợp AI (Claude Code hoặc Cursor)
 :::
 ## Bước 1: Dọn dẹp các tài liệu lập kế hoạch đã hoàn tất
 Nếu bạn đã hoàn thành toàn bộ epic và story trong PRD theo quy trình BMad, hãy dọn dẹp những tệp đó. Bạn có thể lưu trữ, xóa đi, hoặc dựa vào lịch sử phiên bản nếu cần. Không nên giữ các tệp này trong:
 - `docs/`
 - `_bmad-output/planning-artifacts/`
 - `_bmad-output/implementation-artifacts/`
 ## Bước 2: Tạo Project Context
 :::tip[Khuyến dùng cho dự án hiện có]
 Hãy tạo `project-context.md` để ghi lại các pattern và quy ước trong codebase hiện tại. Điều này giúp các agent AI tuân theo các thực hành sẵn có khi thực hiện thay đổi.
 :::
 Chạy workflow tạo project context:
 ```bash
 bmad-generate-project-context
 ```
 Workflow này sẽ quét codebase để nhận diện:
 - Stack công nghệ và các phiên bản
 - Các pattern tổ chức code
 - Quy ước đặt tên
 - Cách tiếp cận kiểm thử
 - Các pattern đặc thù framework
 Bạn có thể xem lại và chỉnh sửa tệp được tạo, hoặc tự tạo tệp tại `_bmad-output/project-context.md` nếu muốn.
 [Tìm hiểu thêm về project context](../explanation/project-context.md)
 ## Bước 3: Duy trì tài liệu dự án chất lượng
 Thư mục `docs/` của bạn nên chứa tài liệu ngắn gọn, có tổ chức tốt, và phản ánh chính xác dự án:
 - Mục tiêu và lý do kinh doanh
 - Quy tắc nghiệp vụ
 - Kiến trúc
 - Bất kỳ thông tin dự án nào khác có liên quan
 Với các dự án phức tạp, hãy cân nhắc dùng workflow `bmad-document-project`. Nó có các biến thể lúc chạy có thể quét toàn bộ dự án và tài liệu hóa trạng thái thực tế hiện tại của hệ thống.
 ## Bước 4: Nhờ trợ giúp
 ### BMad-Help: Điểm bắt đầu của bạn
 **Hãy chạy `bmad-help` bất cứ lúc nào bạn không chắc cần làm gì tiếp theo.** Công cụ hướng dẫn thông minh này:
 - Kiểm tra dự án để xem những gì đã được hoàn thành
 - Đưa ra tùy chọn dựa trên các module bạn đã cài
 - Hiểu các câu hỏi bằng ngôn ngữ tự nhiên
 ```text
 bmad-help Tôi có một ứng dụng Rails đã tồn tại, tôi nên bắt đầu từ đâu?
 bmad-help Điểm khác nhau giữa quick-flow và full method là gì?
 bmad-help Cho tôi xem những workflow đang có
 ```
 BMad-Help cũng **tự động chạy ở cuối mỗi workflow**, đưa ra hướng dẫn rõ ràng về việc cần làm tiếp theo.
 ### Chọn cách tiếp cận
 Bạn có hai lựa chọn chính, tùy thuộc vào phạm vi thay đổi:
 | Phạm vi | Cách tiếp cận được khuyến nghị |
 | --- | --- |
 | **Cập nhật hoặc bổ sung nhỏ** | Chạy `bmad-quick-dev` để làm rõ ý định, lập kế hoạch, triển khai và review trong một workflow duy nhất. Quy trình BMad Method đầy đủ có thể là quá mức cần thiết. |
 | **Thay đổi hoặc bổ sung lớn** | Bắt đầu với BMad Method, áp dụng mức độ chặt chẽ phù hợp với nhu cầu của bạn. |
 ### Khi tạo PRD
 Khi tạo brief hoặc đi thẳng vào PRD, đảm bảo agent:
 - Tìm và phân tích tài liệu dự án hiện có
 - Đọc đúng bối cảnh về hệ thống hiện tại của bạn
 Bạn có thể chủ động hướng dẫn agent, nhưng mục tiêu là đảm bảo tính năng mới tích hợp tốt với hệ thống đã có.
 ### Cân nhắc về UX
 Công việc UX là tùy chọn. Quyết định này không phụ thuộc vào việc dự án có UX hay không, mà phụ thuộc vào:
 - Bạn có định thay đổi UX hay không
 - Bạn có cần thiết kế hay pattern UX mới đáng kể hay không
 Nếu thay đổi của bạn chỉ là những cập nhật nhỏ trên các màn hình hiện có mà bạn đã hài lòng, thì không cần một quy trình UX đầy đủ.
 ### Cân nhắc về kiến trúc
 Khi làm kiến trúc, đảm bảo kiến trúc sư:
 - Sử dụng đúng các tệp tài liệu cần thiết
 - Quét codebase hiện có
 Cần đặc biệt chú ý để tránh tái phát minh bánh xe hoặc đưa ra quyết định không phù hợp với kiến trúc hiện tại.
 ## Thông tin thêm
 - **[Quick Fixes](./quick-fixes.md)** - Sửa lỗi và thay đổi ad-hoc
 - **[Câu hỏi thường gặp cho dự án đã tồn tại](../explanation/established-projects-faq.md)** - Những câu hỏi phổ biến khi làm việc với dự án đã tồn tại
--- a/docs/vi-vn/how-to/get-answers-about-bmad.md
+++ b/docs/vi-vn/how-to/get-answers-about-bmad.md
@ -0,0 +1,135 @@
 ---
 title: "Cách tìm câu trả lời về BMad"
 description: Sử dụng LLM để tự nhanh chóng trả lời các câu hỏi về BMad
 sidebar:
        order: 4
 ---
 ## Bắt đầu tại đây: BMad-Help
 **Cách nhanh nhất để tìm câu trả lời về BMad là dùng skill `bmad-help`.** Đây là công cụ hướng dẫn thông minh có thể trả lời hơn 80% các câu hỏi và có sẵn ngay trong IDE khi bạn làm việc.
 BMad-Help không chỉ là công cụ tra cứu, nó còn:
 - **Kiểm tra dự án của bạn** để xem những gì đã hoàn thành
 - **Hiểu ngôn ngữ tự nhiên** - đặt câu hỏi bằng ngôn ngữ bình thường
 - **Thay đổi theo module đã cài** - hiển thị các lựa chọn liên quan
 - **Tự động chạy sau workflow** - nói rõ bạn cần làm gì tiếp theo
 - **Đề xuất tác vụ đầu tiên cần thiết** - không cần đoán nên bắt đầu từ đâu
 ### Cách dùng BMad-Help
 Gọi nó trực tiếp trong phiên AI của bạn:
 ```text
 bmad-help
 ```
 :::tip
 Bạn cũng có thể dùng `/bmad-help` hoặc `$bmad-help` tùy nền tảng, nhưng chỉ `bmad-help` là cách nên hoạt động mọi nơi.
 :::
 Kết hợp với câu hỏi ngôn ngữ tự nhiên:
 ```text
 bmad-help Tôi có ý tưởng SaaS và đã biết tất cả tính năng. Tôi nên bắt đầu từ đâu?
 bmad-help Tôi có những lựa chọn nào cho thiết kế UX?
 bmad-help Tôi đang bị mắc ở workflow PRD
 bmad-help Cho tôi xem tôi đã làm được gì đến giờ
 ```
 BMad-Help sẽ trả lời:
 - Điều gì được khuyến nghị cho tình huống của bạn
 - Tác vụ đầu tiên cần thiết là gì
 - Phần còn lại của quy trình trông thế nào
 ## Khi nào nên dùng tài liệu này
 Hãy xem phần này khi:
 - Bạn muốn hiểu kiến trúc hoặc nội bộ của BMad
 - Bạn cần câu trả lời nằm ngoài phạm vi BMad-Help cung cấp
 - Bạn đang nghiên cứu BMad trước khi cài đặt
 - Bạn muốn tự khám phá source code trực tiếp
 ## Các bước thực hiện
 ### 1. Chọn nguồn thông tin
 | Nguồn | Phù hợp nhất cho | Ví dụ |
 | --- | --- | --- |
 | **Thư mục `_bmad`** | Cách BMad vận hành: agent, workflow, prompt | "PM agent làm gì?" |
 | **Toàn bộ repo GitHub** | Lịch sử, installer, kiến trúc | "v6 thay đổi gì?" |
 | **`llms-full.txt`** | Tổng quan nhanh từ tài liệu | "Giải thích bốn giai đoạn của BMad" |
 Thư mục `_bmad` được tạo khi bạn cài đặt BMad. Nếu chưa có, hãy clone repo thay thế.
 ### 2. Cho AI của bạn truy cập nguồn thông tin
 **Nếu AI của bạn đọc được tệp (Claude Code, Cursor, ...):**
 - **Đã cài BMad:** Trỏ đến thư mục `_bmad` và hỏi trực tiếp
 - **Cần bối cảnh sâu hơn:** Clone [repo đầy đủ](https://github.com/bmad-code-org/BMAD-METHOD)
 **Nếu bạn dùng ChatGPT hoặc Claude.ai:**
 Nạp `llms-full.txt` vào phiên làm việc:
 ```text
 https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt
 ```
 ### 3. Đặt câu hỏi
 :::note[Ví dụ]
 **Q:** "Hãy chỉ tôi cách nhanh nhất để xây dựng một thứ gì đó bằng BMad"
 **A:** Dùng Quick Flow: Chạy `bmad-quick-dev` - nó sẽ làm rõ ý định, lập kế hoạch, triển khai, review và trình bày kết quả trong một workflow duy nhất, bỏ qua các giai đoạn lập kế hoạch đầy đủ.
 :::
 ## Bạn nhận được gì
 Các câu trả lời trực tiếp về BMad: agent hoạt động ra sao, workflow làm gì, tại sao cấu trúc lại được tổ chức như vậy, mà không cần chờ người khác trả lời.
 ## Mẹo
 - **Xác minh những câu trả lời gây bất ngờ** - LLM vẫn có lúc nhầm. Hãy kiểm tra tệp nguồn hoặc hỏi trên Discord.
 - **Đặt câu hỏi cụ thể** - "Bước 3 trong workflow PRD làm gì?" tốt hơn "PRD hoạt động ra sao?"
 ## Vẫn bị mắc?
 Đã thử cách tiếp cận bằng LLM mà vẫn cần trợ giúp? Lúc này bạn đã có một câu hỏi tốt hơn để đem đi hỏi.
 | Kênh | Dùng cho |
 | --- | --- |
 | `#bmad-method-help` | Câu hỏi nhanh (trò chuyện thời gian thực) |
 | `help-requests` forum | Câu hỏi chi tiết (có thể tìm lại, tồn tại lâu dài) |
 | `#suggestions-feedback` | Ý tưởng và đề xuất tính năng |
 | `#report-bugs-and-issues` | Báo cáo lỗi |
 **Discord:** [discord.gg/gk8jAdXWmj](https://discord.gg/gk8jAdXWmj)
 **GitHub Issues:** [github.com/bmad-code-org/BMAD-METHOD/issues](https://github.com/bmad-code-org/BMAD-METHOD/issues) (dành cho các lỗi rõ ràng)
 *Chính bạn,*
        *đang mắc kẹt*
             *trong hàng đợi -*
                      *đợi*
                              *ai?*
 *Mã nguồn*
        *nằm ngay đó,*
                *rõ như ban ngày!*
 *Hãy trỏ*
        *cho máy của bạn.*
                    *Thả nó đi.*
 *Nó đọc.*
        *Nó nói.*
                *Cứ hỏi -*
 *Sao phải chờ*
        *đến ngày mai*
                *khi bạn đã có*
                        *ngày hôm nay?*
 *- Claude*
--- a/docs/vi-vn/how-to/install-bmad.md
+++ b/docs/vi-vn/how-to/install-bmad.md
@ -0,0 +1,116 @@
 ---
 title: "Cách cài đặt BMad"
 description: Hướng dẫn từng bước để cài đặt BMad vào dự án của bạn
 sidebar:
  order: 1
 ---
 Sử dụng lệnh `npx bmad-method install` để thiết lập BMad trong dự án của bạn với các module và công cụ AI theo lựa chọn.
 Nếu bạn muốn dùng trình cài đặt không tương tác và cung cấp toàn bộ tùy chọn ngay trên dòng lệnh, xem [hướng dẫn này](./non-interactive-installation.md).
 ## Khi nào nên dùng
 - Bắt đầu một dự án mới với BMad
 - Thêm BMad vào một codebase hiện có
 - Cập nhật bản cài đặt BMad hiện tại
 :::note[Điều kiện tiên quyết]
 - **Node.js** 20+ (bắt buộc cho trình cài đặt)
 - **Git** (khuyến nghị)
 - **Công cụ AI** (Claude Code, Cursor, hoặc tương tự)
 :::
 ## Các bước thực hiện
 ### 1. Chạy trình cài đặt
 ```bash
 npx bmad-method install
 ```
 :::tip[Muốn dùng bản prerelease mới nhất?]
 Sử dụng dist-tag `next`:
 ```bash
 npx bmad-method@next install
 ```
 Cách này giúp bạn nhận các thay đổi mới sớm hơn, đổi lại khả năng biến động cao hơn bản cài đặt mặc định.
 :::
 :::tip[Bản rất mới]
 Để cài đặt trực tiếp từ nhánh `main` mới nhất (có thể không ổn định):
 ```bash
 npx github:bmad-code-org/BMAD-METHOD install
 ```
 :::
 ### 2. Chọn vị trí cài đặt
 Trình cài đặt sẽ hỏi bạn muốn đặt các tệp BMad ở đâu:
 - Thư mục hiện tại (khuyến nghị cho dự án mới nếu bạn tự tạo thư mục và chạy lệnh từ bên trong nó)
 - Đường dẫn tùy chọn
 ### 3. Chọn công cụ AI
 Chọn các công cụ AI bạn đang dùng:
 - Claude Code
 - Cursor
 - Các công cụ khác
 Mỗi công cụ có cách tích hợp skill riêng. Trình cài đặt sẽ tạo các tệp prompt nhỏ để kích hoạt workflow và agent, và đặt chúng vào đúng vị trí mà công cụ của bạn mong đợi.
 :::note[Kích hoạt skill]
 Một số nền tảng yêu cầu bật skill trong cài đặt trước khi chúng xuất hiện. Nếu bạn đã cài BMad mà chưa thấy skill, hãy kiểm tra cài đặt của nền tảng hoặc hỏi trợ lý AI cách bật skill.
 :::
 ### 4. Chọn module
 Trình cài đặt sẽ hiện các module có sẵn. Chọn những module bạn cần - phần lớn người dùng chỉ cần **BMad Method** (module phát triển phần mềm).
 ### 5. Làm theo các prompt
 Trình cài đặt sẽ hướng dẫn các bước còn lại - nội dung tùy chỉnh, cài đặt, và các tùy chọn khác.
 ## Bạn nhận được gì
 ```text
 du-an-cua-ban/
 ├── _bmad/
 │   ├── bmm/            # Các module bạn đã chọn
 │   │   └── config.yaml # Cài đặt module (nếu bạn cần thay đổi sau này)
 │   ├── core/           # Module core bắt buộc
 │   └── ...
 ├── _bmad-output/       # Các artifact được tạo ra
 ├── .claude/            # Claude Code skills (nếu dùng Claude Code)
 │   └── skills/
 │       ├── bmad-help/
 │       ├── bmad-persona/
 │       └── ...
 └── .cursor/            # Cursor skills (nếu dùng Cursor)
    └── skills/
        └── ...
 ```
 ## Xác minh cài đặt
 Chạy `bmad-help` để xác minh mọi thứ hoạt động và xem bạn nên làm gì tiếp theo.
 **BMad-Help là công cụ hướng dẫn thông minh** sẽ:
 - Xác nhận bản cài đặt hoạt động đúng
 - Hiển thị những gì có sẵn dựa trên module đã cài
 - Đề xuất bước đầu tiên của bạn
 Bạn cũng có thể hỏi nó:
 ```text
 bmad-help Tôi vừa cài xong, giờ nên làm gì đầu tiên?
 bmad-help Tôi có những lựa chọn nào cho một dự án SaaS?
 ```
 ## Khắc phục sự cố
 **Trình cài đặt báo lỗi** - Sao chép toàn bộ output vào trợ lý AI của bạn và để nó phân tích.
 **Cài đặt xong nhưng sau đó có thứ không hoạt động** - AI của bạn cần bối cảnh BMad để hỗ trợ. Xem [Cách tìm câu trả lời về BMad](./get-answers-about-bmad.md) để biết cách cho AI truy cập đúng nguồn thông tin.
--- a/docs/vi-vn/how-to/non-interactive-installation.md
+++ b/docs/vi-vn/how-to/non-interactive-installation.md
@ -0,0 +1,184 @@
 ---
 title: Cài đặt không tương tác
 description: Cài đặt BMad bằng các cờ dòng lệnh cho pipeline CI/CD và triển khai tự động
 sidebar:
  order: 2
 ---
 Sử dụng các cờ dòng lệnh để cài đặt BMad mà không cần tương tác. Cách này hữu ích cho:
 ## Khi nào nên dùng
 - Triển khai tự động và pipeline CI/CD
 - Cài đặt bằng script
 - Cài đặt hàng loạt trên nhiều dự án
 - Cài đặt nhanh với cấu hình đã biết trước
 :::note[Điều kiện tiên quyết]
 Yêu cầu [Node.js](https://nodejs.org) v20+ và `npx` (đi kèm với npm).
 :::
 ## Các cờ khả dụng
 ### Tùy chọn cài đặt
 | Cờ | Mô tả | Ví dụ |
 |------|-------------|---------|
 | `--directory <path>` | Thư mục cài đặt | `--directory ~/projects/myapp` |
 | `--modules <modules>` | Danh sách ID module, cách nhau bởi dấu phẩy | `--modules bmm,bmb` |
 | `--tools <tools>` | Danh sách ID công cụ/IDE, cách nhau bởi dấu phẩy (dùng `none` để bỏ qua) | `--tools claude-code,cursor` hoặc `--tools none` |
 | `--custom-content <paths>` | Danh sách đường dẫn đến module tùy chỉnh, cách nhau bởi dấu phẩy | `--custom-content ~/my-module,~/another-module` |
 | `--action <type>` | Hành động cho bản cài đặt hiện có: `install` (mặc định), `update`, hoặc `quick-update` | `--action quick-update` |
 ### Cấu hình cốt lõi
 | Cờ | Mô tả | Mặc định |
 |------|-------------|---------|
 | `--user-name <name>` | Tên để agent sử dụng | Tên người dùng hệ thống |
 | `--communication-language <lang>` | Ngôn ngữ giao tiếp của agent | Tiếng Anh |
 | `--document-output-language <lang>` | Ngôn ngữ đầu ra tài liệu | Tiếng Anh |
 | `--output-folder <path>` | Đường dẫn thư mục output (xem quy tắc resolve bên dưới) | `_bmad-output` |
 #### Quy tắc resolve đường dẫn output folder
 Giá trị truyền vào `--output-folder` (hoặc nhập ở chế độ tương tác) sẽ được resolve theo các quy tắc sau:
 | Loại đầu vào | Ví dụ | Được resolve thành |
 |------|-------------|---------|
 | Đường dẫn tương đối (mặc định) | `_bmad-output` | `<project-root>/_bmad-output` |
 | Đường dẫn tương đối có traversal | `../../shared-outputs` | Đường dẫn tuyệt đối đã được chuẩn hóa, ví dụ `/Users/me/shared-outputs` |
 | Đường dẫn tuyệt đối | `/Users/me/shared-outputs` | Giữ nguyên như đã nhập, **không** thêm project root vào trước |
 Đường dẫn sau khi resolve là đường dẫn mà agent và workflow sẽ dùng lúc runtime để ghi file đầu ra. Việc dùng đường dẫn tuyệt đối hoặc đường dẫn tương đối có traversal cho phép bạn chuyển toàn bộ artifact sinh ra sang một thư mục nằm ngoài cây dự án, hữu ích với thư mục dùng chung hoặc cấu trúc monorepo.
 ### Tùy chọn khác
 | Cờ | Mô tả |
 |------|-------------|
 | `-y, --yes` | Chấp nhận toàn bộ mặc định và bỏ qua prompt |
 | `-d, --debug` | Bật output debug cho quá trình tạo manifest |
 ## ID module
 Những ID module có thể dùng với cờ `--modules`:
 - `bmm` - BMad Method Master
 - `bmb` - BMad Builder
 Kiểm tra [BMad registry](https://github.com/bmad-code-org) để xem các module ngoài được hỗ trợ.
 ## ID công cụ/IDE
 Những ID công cụ có thể dùng với cờ `--tools`:
 **Khuyến dùng:** `claude-code`, `cursor`
 Chạy `npx bmad-method install` một lần ở chế độ tương tác để xem danh sách đầy đủ hiện tại của các công cụ được hỗ trợ, hoặc xem [cấu hình platform codes](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/installer/ide/platform-codes.yaml).
 ## Các chế độ cài đặt
 | Chế độ | Mô tả | Ví dụ |
 |------|-------------|---------|
 | Hoàn toàn không tương tác | Cung cấp đầy đủ cờ để bỏ qua tất cả prompt | `npx bmad-method install --directory . --modules bmm --tools claude-code --yes` |
 | Bán tương tác | Cung cấp một số cờ, BMad hỏi thêm phần còn lại | `npx bmad-method install --directory . --modules bmm` |
 | Chỉ dùng mặc định | Chấp nhận tất cả giá trị mặc định với `-y` | `npx bmad-method install --yes` |
 | Không cấu hình công cụ | Bỏ qua cấu hình công cụ/IDE | `npx bmad-method install --modules bmm --tools none` |
 ## Ví dụ
 ### Cài đặt cho pipeline CI/CD
 ```bash
 #!/bin/bash
 # install-bmad.sh
 npx bmad-method install \
  --directory "${GITHUB_WORKSPACE}" \
  --modules bmm \
  --tools claude-code \
  --user-name "CI Bot" \
  --communication-language English \
  --document-output-language English \
  --output-folder _bmad-output \
  --yes
 ```
 ### Cập nhật bản cài đặt hiện có
 ```bash
 npx bmad-method install \
  --directory ~/projects/myapp \
  --action update \
  --modules bmm,bmb,custom-module
 ```
 ### Quick Update (giữ nguyên cài đặt)
 ```bash
 npx bmad-method install \
  --directory ~/projects/myapp \
  --action quick-update
 ```
 ### Cài đặt với nội dung tùy chỉnh
 ```bash
 npx bmad-method install \
  --directory ~/projects/myapp \
  --modules bmm \
  --custom-content ~/my-custom-module,~/another-module \
  --tools claude-code
 ```
 ## Bạn nhận được gì
 - Thư mục `_bmad/` đã được cấu hình đầy đủ trong dự án của bạn
 - Agent và workflow đã được cấu hình theo module và công cụ bạn chọn
 - Thư mục `_bmad-output/` để lưu các artifact được tạo
 ## Kiểm tra và xử lý lỗi
 BMad sẽ kiểm tra tất cả các cờ được cung cấp:
 - **Directory** - Phải là đường dẫn hợp lệ và có quyền ghi
 - **Modules** - Cảnh báo nếu ID module không hợp lệ (nhưng không thất bại)
 - **Tools** - Cảnh báo nếu ID công cụ không hợp lệ (nhưng không thất bại)
 - **Custom Content** - Mỗi đường dẫn phải chứa tệp `module.yaml` hợp lệ
 - **Action** - Phải là một trong: `install`, `update`, `quick-update`
 Giá trị không hợp lệ sẽ dẫn đến một trong các trường hợp sau:
 1. Hiện lỗi và thoát (với các tùy chọn quan trọng như directory)
 2. Hiện cảnh báo và bỏ qua (với mục tùy chọn như custom content)
 3. Quay lại hỏi interactive (với giá trị bắt buộc bị thiếu)
 :::tip[Thực hành tốt]
 - Dùng đường dẫn tuyệt đối cho `--directory` để tránh nhầm lẫn
 - Dùng đường dẫn tuyệt đối cho `--output-folder` khi bạn muốn ghi artifact ra ngoài cây dự án, ví dụ vào một thư mục output dùng chung trong monorepo
 - Thử nghiệm cờ ở máy local trước khi đưa vào pipeline CI/CD
 - Kết hợp với `-y` nếu bạn muốn cài đặt hoàn toàn không cần can thiệp
 - Dùng `--debug` nếu gặp vấn đề trong quá trình cài đặt
 :::
 ## Khắc phục sự cố
 ### Cài đặt thất bại với lỗi "Invalid directory"
 - Thư mục đích phải tồn tại (hoặc thư mục cha của nó phải tồn tại)
 - Bạn cần quyền ghi
 - Đường dẫn phải là tuyệt đối, hoặc tương đối đúng với thư mục hiện tại
 ### Không tìm thấy module
 - Xác minh ID module có đúng không
 - Module bên ngoài phải có sẵn trong registry
 ### Đường dẫn custom content không hợp lệ
 Đảm bảo mỗi đường dẫn custom content:
 - Trỏ tới một thư mục
 - Chứa tệp `module.yaml` ở cấp gốc
 - Có trường `code` trong tệp `module.yaml`
 :::note[Vẫn bị mắc?]
 Chạy với `--debug` để xem output chi tiết, thử chế độ interactive để cô lập vấn đề, hoặc báo cáo tại <https://github.com/bmad-code-org/BMAD-METHOD/issues>.
 :::
--- a/docs/vi-vn/how-to/project-context.md
+++ b/docs/vi-vn/how-to/project-context.md
@ -0,0 +1,127 @@
 ---
 title: "Quản lý Project Context"
 description: Tạo và duy trì project-context.md để định hướng cho các agent AI
 sidebar:
  order: 8
 ---
 Sử dụng tệp `project-context.md` để đảm bảo các agent AI tuân theo ưu tiên kỹ thuật và quy tắc triển khai của dự án trong suốt mọi workflow. Để đảm bảo tệp này luôn sẵn có, bạn cũng có thể thêm dòng `Important project context and conventions are located in [path to project context]/project-context.md` vào file context của công cụ hoặc file always rules của bạn (như `AGENTS.md`).
 :::note[Điều kiện tiên quyết]
 - Đã cài BMad Method
 - Hiểu stack công nghệ và các quy ước của dự án
 :::
 ## Khi nào nên dùng
 - Bạn có các ưu tiên kỹ thuật rõ ràng trước khi bắt đầu làm kiến trúc
 - Bạn đã hoàn thành kiến trúc và muốn ghi lại các quyết định để phục vụ triển khai
 - Bạn đang làm việc với một codebase hiện có có những pattern đã ổn định
 - Bạn thấy các agent đưa ra quyết định không nhất quán giữa các story
 ## Bước 1: Chọn cách tiếp cận
 **Tự tạo bằng tay** - Phù hợp nhất khi bạn biết rõ cần tài liệu hóa quy tắc nào
 **Tạo sau kiến trúc** - Phù hợp để ghi lại các quyết định đã được đưa ra trong giai đoạn solutioning
 **Tạo cho dự án hiện có** - Phù hợp để khám phá pattern trong các codebase đã tồn tại
 ## Bước 2: Tạo tệp
 ### Lựa chọn A: Tạo thủ công
 Tạo tệp tại `_bmad-output/project-context.md`:
 ```bash
 mkdir -p _bmad-output
 touch _bmad-output/project-context.md
 ```
 Thêm stack công nghệ và các quy tắc triển khai của bạn:
 ```markdown
 ---
 project_name: 'MyProject'
 user_name: 'YourName'
 date: '2026-02-15'
 sections_completed: ['technology_stack', 'critical_rules']
 ---
 # Project Context for AI Agents
 ## Technology Stack & Versions
 - Node.js 20.x, TypeScript 5.3, React 18.2
 - State: Zustand
 - Testing: Vitest, Playwright
 - Styling: Tailwind CSS
 ## Critical Implementation Rules
 **TypeScript:**
 - Strict mode enabled, no `any` types
 - Use `interface` for public APIs, `type` for unions
 **Code Organization:**
 - Components in `/src/components/` with co-located tests
 - API calls use `apiClient` singleton — never fetch directly
 **Testing:**
 - Unit tests focus on business logic
 - Integration tests use MSW for API mocking
 ```
 ### Lựa chọn B: Tạo sau khi hoàn thành kiến trúc
 Chạy workflow trong một phiên chat mới:
 ```bash
 bmad-generate-project-context
 ```
 Workflow sẽ quét tài liệu kiến trúc và tệp dự án để tạo tệp context ghi lại các quyết định đã được đưa ra.
 ### Lựa chọn C: Tạo cho dự án hiện có
 Với các dự án hiện có, chạy:
 ```bash
 bmad-generate-project-context
 ```
 Workflow sẽ phân tích codebase để nhận diện quy ước, sau đó tạo tệp context để bạn xem lại và chỉnh sửa.
 ## Bước 3: Xác minh nội dung
 Xem lại tệp được tạo và đảm bảo nó ghi đúng:
 - Các phiên bản công nghệ chính xác
 - Đúng các quy ước thực tế của bạn (không phải các best practice chung chung)
 - Các quy tắc giúp tránh những lỗi thường gặp
 - Các pattern đặc thù framework
 Chỉnh sửa thủ công để thêm phần còn thiếu hoặc loại bỏ những chỗ không chính xác.
 ## Bạn nhận được gì
 Một tệp `project-context.md` sẽ:
 - Đảm bảo tất cả agent tuân theo cùng một bộ quy ước
 - Ngăn các quyết định không nhất quán giữa các story
 - Ghi lại các quyết định kiến trúc cho giai đoạn triển khai
 - Làm tài liệu tham chiếu cho các pattern và quy tắc của dự án
 ## Mẹo
 :::tip[Thực hành tốt]
 - **Tập trung vào điều không hiển nhiên** - Ghi lại những pattern agent dễ bỏ sót (ví dụ: "Dùng JSDoc cho mọi lớp public"), thay vì các quy tắc phổ quát như "đặt tên biến có ý nghĩa".
 - **Gọn nhẹ** - Tệp này được nạp trong mọi workflow triển khai. Tệp quá dài sẽ tốn context. Hãy bỏ qua nội dung chỉ áp dụng cho phạm vi hẹp hoặc một vài story cụ thể.
 - **Cập nhật khi cần** - Sửa thủ công khi pattern thay đổi, hoặc tạo lại sau các thay đổi kiến trúc lớn.
 - Áp dụng được cho cả Quick Flow lẫn quy trình BMad Method đầy đủ.
 :::
 ## Bước tiếp theo
 - [**Giải thích về Project Context**](../explanation/project-context.md) - Tìm hiểu sâu hơn cách nó hoạt động
 - [**Bản đồ workflow**](../reference/workflow-map.md) - Xem workflow nào sử dụng project context
--- a/docs/vi-vn/how-to/quick-fixes.md
+++ b/docs/vi-vn/how-to/quick-fixes.md
@ -0,0 +1,95 @@
 ---
 title: "Quick Fixes"
 description: Cách thực hiện các sửa nhanh và thay đổi ad-hoc
 sidebar:
  order: 5
 ---
 Sử dụng **Quick Dev** cho sửa lỗi, refactor, hoặc các thay đổi nhỏ có mục tiêu rõ ràng mà không cần quy trình BMad Method đầy đủ.
 ## Khi nào nên dùng
 - Sửa lỗi khi nguyên nhân đã rõ ràng
 - Refactor nhỏ (đổi tên, tách hàm, tái cấu trúc) nằm trong một vài tệp
 - Điều chỉnh tính năng nhỏ hoặc thay đổi cấu hình
 - Cập nhật dependency
 :::note[Điều kiện tiên quyết]
 - Đã cài BMad Method (`npx bmad-method install`)
 - Một IDE tích hợp AI (Claude Code, Cursor, hoặc tương tự)
 :::
 ## Các bước thực hiện
 ### 1. Bắt đầu một phiên chat mới
 Mở **một phiên chat mới** trong AI IDE của bạn. Tái sử dụng một phiên từ workflow trước dễ gây xung đột context.
 ### 2. Mô tả ý định của bạn
 Quick Dev nhận ý định dạng tự do - trước, cùng lúc, hoặc sau khi gọi workflow. Ví dụ:
 ```text
 run quick-dev — Sửa lỗi validate đăng nhập cho phép mật khẩu rỗng.
 ```
 ```text
 run quick-dev — fix https://github.com/org/repo/issues/42
 ```
 ```text
 run quick-dev — thực hiện ý định trong _bmad-output/implementation-artifacts/my-intent.md
 ```
 ```text
 Tôi nghĩ vấn đề nằm ở auth middleware, nó không kiểm tra hạn của token.
 Để tôi xem... đúng rồi, src/auth/middleware.ts dòng 47 bỏ qua
 hoàn toàn phần kiểm tra exp. run quick-dev
 ```
 ```text
 run quick-dev
 > Bạn muốn làm gì?
 Refactor UserService sang dùng async/await thay vì callbacks.
 ```
 Văn bản thường, đường dẫn tệp, URL issue GitHub, liên kết bug tracker - bất kỳ thứ gì LLM có thể suy ra thành một ý định cụ thể.
 ### 3. Trả lời câu hỏi và phê duyệt
 Quick Dev có thể đặt câu hỏi làm rõ hoặc đưa ra một bản spec ngắn để bạn phê duyệt trước khi triển khai. Hãy trả lời và phê duyệt khi bạn thấy kế hoạch đã ổn.
 ### 4. Review và push
 Quick Dev sẽ triển khai thay đổi, tự review công việc của mình, sửa các vấn đề phát hiện được và commit vào local. Khi hoàn thành, nó sẽ mở các tệp bị ảnh hưởng trong editor.
 - Xem nhanh diff để xác nhận thay đổi đúng với ý định của bạn
 - Nếu có gì không ổn, nói cho agent biết cần sửa gì - nó có thể lặp lại ngay trong cùng phiên
 Khi đã hài lòng, push commit. Quick Dev sẽ đề xuất push và tạo PR cho bạn.
 :::caution[Nếu có thứ bị vỡ]
 Nếu thay đổi đã push gây sự cố ngoài ý muốn, dùng `git revert HEAD` để hoàn tác commit cuối một cách sạch sẽ. Sau đó bắt đầu một phiên chat mới và chạy lại Quick Dev để thử hướng khác.
 :::
 ## Bạn nhận được gì
 - Các tệp nguồn đã được sửa với bản fix hoặc refactor
 - Test đã pass (nếu dự án có bộ test)
 - Một commit sẵn sàng để push, dùng conventional commit message
 ## Công việc trì hoãn
 Quick Dev giữ mỗi lần chạy tập trung vào một mục tiêu duy nhất. Nếu yêu cầu của bạn có nhiều mục tiêu độc lập, hoặc review phát hiện các vấn đề tồn tại sẵn không liên quan đến thay đổi hiện tại, Quick Dev sẽ đưa chúng vào tệp `deferred-work.md` trong thư mục implementation artifacts thay vì cố gắng xử lý tất cả một lúc.
 Hãy kiểm tra tệp này sau mỗi lần chạy - đó là backlog các việc bạn cần quay lại sau. Mỗi mục trì hoãn có thể được đưa vào một lần chạy Quick Dev mới.
 ## Khi nào nên nâng cấp lên quy trình lập kế hoạch đầy đủ
 Cân nhắc dùng toàn bộ BMad Method khi:
 - Thay đổi ảnh hưởng nhiều hệ thống hoặc cần cập nhật đồng bộ trên nhiều tệp
 - Bạn chưa chắc phạm vi và cần làm rõ yêu cầu trước
 - Bạn cần ghi lại tài liệu hoặc quyết định kiến trúc cho cả nhóm
 Xem [Quick Dev](../explanation/quick-dev.md) để hiểu rõ hơn Quick Dev nằm ở đâu trong BMad Method.
--- a/docs/vi-vn/how-to/shard-large-documents.md
+++ b/docs/vi-vn/how-to/shard-large-documents.md
@ -0,0 +1,78 @@
 ---
 title: "Hướng dẫn chia nhỏ tài liệu"
 description: Tách các tệp markdown lớn thành nhiều tệp nhỏ có tổ chức để quản lý context tốt hơn
 sidebar:
       order: 9
 ---
 Sử dụng công cụ `bmad-shard-doc` nếu bạn cần tách các tệp markdown lớn thành nhiều tệp nhỏ có tổ chức để quản lý context tốt hơn.
 :::caution[Đã ngừng khuyến nghị]
 Đây không còn là cách được khuyến nghị, và trong thời gian tới khi workflow được cập nhật và đa số LLM/công cụ lớn hỗ trợ subprocesses, việc này sẽ không còn cần thiết.
 :::
 ## Khi nào nên dùng
 Chỉ dùng cách này nếu bạn nhận thấy tổ hợp công cụ / model bạn đang dùng không thể nạp và đọc đầy đủ tất cả tài liệu đầu vào khi cần.
 ## Chia nhỏ tài liệu là gì?
 Chia nhỏ tài liệu là việc tách các tệp markdown lớn thành nhiều tệp nhỏ có tổ chức dựa trên các tiêu đề cấp 2 (`## Tiêu đề`).
 ### Kiến trúc
 ```text
 Trước khi chia nhỏ:
 _bmad-output/planning-artifacts/
 └── PRD.md (tệp lớn 50k token)
 Sau khi chia nhỏ:
 _bmad-output/planning-artifacts/
 └── prd/
       ├── index.md                    # Mục lục kèm mô tả
       ├── overview.md                 # Phần 1
       ├── user-requirements.md        # Phần 2
       ├── technical-requirements.md   # Phần 3
       └── ...                         # Các phần bổ sung
 ```
 ## Các bước thực hiện
 ### 1. Chạy công cụ Shard-Doc
 ```bash
 /bmad-shard-doc
 ```
 ### 2. Làm theo quy trình tương tác
 ```text
 Agent: Bạn muốn chia nhỏ tài liệu nào?
 User: docs/PRD.md
 Agent: Thư mục đích mặc định: docs/prd/
       Chấp nhận mặc định? [y/n]
 User: y
 Agent: Đang chia nhỏ PRD.md...
       ✓ Đã tạo 12 tệp theo từng phần
       ✓ Đã tạo index.md
       ✓ Hoàn tất!
 ```
 ## Cơ chế workflow tìm tài liệu
 Workflow của BMad dùng **hệ thống phát hiện kép**:
 1. **Thử tài liệu nguyên khối trước** - Tìm `document-name.md`
 2. **Kiểm tra bản đã chia nhỏ** - Tìm `document-name/index.md`
 3. **Quy tắc ưu tiên** - Bản nguyên khối được ưu tiên nếu cả hai cùng tồn tại; hãy xóa bản nguyên khối nếu bạn muốn workflow dùng bản đã chia nhỏ
 ## Hỗ trợ trong workflow
 Tất cả workflow BMM đều hỗ trợ cả hai định dạng:
 - Tài liệu nguyên khối
 - Tài liệu đã chia nhỏ
 - Tự động nhận diện
 - Trong suốt với người dùng
--- a/docs/vi-vn/how-to/upgrade-to-v6.md
+++ b/docs/vi-vn/how-to/upgrade-to-v6.md
@ -0,0 +1,100 @@
 ---
 title: "Cách nâng cấp lên v6"
 description: Di chuyển từ BMad v4 sang v6
 sidebar:
  order: 3
 ---
 Sử dụng trình cài đặt BMad để nâng cấp từ v4 lên v6, bao gồm khả năng tự động phát hiện bản cài đặt cũ và hỗ trợ di chuyển.
 ## Khi nào nên dùng
 - Bạn đang dùng BMad v4 (thư mục `.bmad-method`)
 - Bạn muốn chuyển sang kiến trúc v6 mới
 - Bạn có các planning artifact hiện có cần giữ lại
 :::note[Điều kiện tiên quyết]
 - Node.js 20+
 - Bản cài đặt BMad v4 hiện có
 :::
 ## Các bước thực hiện
 ### 1. Chạy trình cài đặt
 Làm theo [Hướng dẫn cài đặt](./install-bmad.md).
 ### 2. Xử lý bản cài đặt cũ
 Khi v4 được phát hiện, bạn có thể:
 - Cho phép trình cài đặt sao lưu và xóa `.bmad-method`
 - Thoát và tự xử lý dọn dẹp thủ công
 Nếu trước đây bạn đặt tên thư mục BMad khác - bạn sẽ phải tự xóa thư mục đó.
 ### 3. Dọn dẹp skill IDE cũ
 Tự xóa các command/skill IDE cũ của v4 - ví dụ nếu bạn dùng Claude Code, hãy tìm các thư mục lồng nhau bắt đầu bằng `bmad` và xóa chúng:
 - `.claude/commands/`
 Các skill v6 mới sẽ được cài tại:
 - `.claude/skills/`
 ### 4. Di chuyển planning artifacts
 **Nếu bạn có tài liệu lập kế hoạch (Brief/PRD/UX/Architecture):**
 Di chuyển chúng vào `_bmad-output/planning-artifacts/` với tên mô tả rõ ràng:
 - Tên tệp PRD nên chứa `PRD`
 - Tên tệp tương ứng nên chứa `brief`, `architecture`, hoặc `ux-design`
 - Tài liệu đã chia nhỏ có thể đặt trong các thư mục con đặt tên phù hợp
 **Nếu bạn đang lập kế hoạch dở dang:** Hãy cân nhắc bắt đầu lại với workflow v6. Bạn vẫn có thể dùng các tài liệu hiện có làm input - các workflow discovery tiên tiến trong v6, kết hợp web search và chế độ plan trong IDE, cho kết quả tốt hơn.
 ### 5. Di chuyển công việc phát triển đang dở dang
 Nếu bạn đã có các story được tạo hoặc đã triển khai:
 1. Hoàn thành cài đặt v6
 2. Đặt `epics.md` hoặc `epics/epic*.md` vào `_bmad-output/planning-artifacts/`
 3. Chạy workflow `bmad-sprint-planning` của Scrum Master
 4. Nói rõ với SM những epic/story nào đã hoàn thành
 ## Bạn nhận được gì
 **Cấu trúc thống nhất của v6:**
 ```text
 du-an-cua-ban/
 ├── _bmad/               # Thư mục cài đặt duy nhất
 │   ├── _config/         # Các tùy chỉnh của bạn
 │   │   └── agents/      # Tệp tùy chỉnh agent
 │   ├── core/            # Framework core dùng chung
 │   ├── bmm/             # Module BMad Method
 │   ├── bmb/             # BMad Builder
 │   └── cis/             # Creative Intelligence Suite
 └── _bmad-output/        # Thư mục output (là thư mục docs trong v4)
 ```
 ## Di chuyển module
 | Module v4 | Trạng thái trong v6 |
 | --- | --- |
 | `.bmad-2d-phaser-game-dev` | Đã được tích hợp vào module BMGD |
 | `.bmad-2d-unity-game-dev` | Đã được tích hợp vào module BMGD |
 | `.bmad-godot-game-dev` | Đã được tích hợp vào module BMGD |
 | `.bmad-infrastructure-devops` | Đã bị ngừng hỗ trợ - agent DevOps mới sắp ra mắt |
 | `.bmad-creative-writing` | Chưa được điều chỉnh - module v6 mới sắp ra mắt |
 ## Các thay đổi chính
 | Khái niệm | v4 | v6 |
 | --- | --- | --- |
 | **Core** | `_bmad-core` thực chất là BMad Method | `_bmad/core/` là framework dùng chung |
 | **Method** | `_bmad-method` | `_bmad/bmm/` |
 | **Config** | Sửa trực tiếp các tệp | `config.yaml` theo từng module |
 | **Documents** | Cần thiết lập trước cho bản chia nhỏ hoặc nguyên khối | Linh hoạt hoàn toàn, tự động quét |
--- a/docs/vi-vn/index.md
+++ b/docs/vi-vn/index.md
@ -0,0 +1,60 @@
 ---
 title: Chào mừng đến với BMad Method
 description: Framework phát triển phần mềm dựa trên AI với các agent chuyên biệt, workflow có hướng dẫn và khả năng lập kế hoạch thông minh
 ---
 BMad Method (**B**uild **M**ore **A**rchitect **D**reams) là một framework phát triển phần mềm dựa trên AI trong hệ sinh thái BMad Method, giúp bạn xây dựng phần mềm xuyên suốt toàn bộ quy trình, từ hình thành ý tưởng và lập kế hoạch cho tới triển khai với agent. Framework này cung cấp các AI agent chuyên biệt, workflow có hướng dẫn, và khả năng lập kế hoạch thông minh thích ứng với độ phức tạp của dự án, dù bạn đang sửa một lỗi nhỏ hay xây dựng một nền tảng doanh nghiệp.
 Nếu bạn đã quen làm việc với các trợ lý AI cho lập trình như Claude, Cursor, hoặc GitHub Copilot, bạn có thể bắt đầu ngay.
 :::note[🚀 V6 đã ra mắt và chúng tôi mới chỉ bắt đầu!]
 Kiến trúc Skills, BMad Builder v1, Dev Loop Automation, và nhiều thứ khác nữa đang được phát triển. **[Xem Roadmap →](/vi-vn/roadmap/)**
 :::
 ## Mới bắt đầu? Hãy xem một Tutorial trước
 Cách nhanh nhất để hiểu BMad là dùng thử nó.
 - **[Bắt đầu với BMad](./tutorials/getting-started.md)** — Cài đặt và hiểu cách BMad hoạt động
 - **[Sơ đồ Workflow](./reference/workflow-map.md)** — Tổng quan trực quan về các phase của BMM, workflow, và cách quản lý context
 :::tip[Muốn vào việc ngay?]
 Cài BMad và dùng skill `bmad-help` — nó sẽ hướng dẫn bạn mọi thứ dựa trên dự án và các module đã cài.
 :::
 ## Cách dùng bộ tài liệu này
 Bộ tài liệu này được chia thành bốn phần, dựa trên mục tiêu của bạn:
 | Phần | Mục đích |
 | ----------------- | ---------------------------------------------------------------------------------------------------------- |
 | **Tutorials** | Thiên về học theo từng bước. Đây là các hướng dẫn tuần tự giúp bạn xây dựng một thứ gì đó. Nếu bạn mới làm quen, hãy bắt đầu ở đây. |
 | **How-To Guides** | Thiên về tác vụ. Đây là các hướng dẫn thực tế để giải quyết một vấn đề cụ thể. Câu hỏi kiểu “Làm sao để tùy chỉnh một agent?” nằm ở phần này. |
 | **Explanation** | Thiên về hiểu bản chất. Đây là các bài phân tích sâu về khái niệm và kiến trúc. Hãy đọc khi bạn muốn hiểu *vì sao*. |
 | **Reference** | Thiên về tra cứu thông tin. Đây là đặc tả kỹ thuật cho agent, workflow, và cấu hình. |
 ## Mở rộng và tùy chỉnh
 Bạn muốn mở rộng BMad bằng các agent, workflow, hoặc module của riêng mình? **[BMad Builder](https://bmad-builder-docs.bmad-method.org/)** cung cấp framework và công cụ để tạo các phần mở rộng tùy chỉnh, dù bạn chỉ bổ sung khả năng mới cho BMad hay xây dựng hẳn một module mới từ đầu.
 ## Bạn cần gì để bắt đầu
 BMad hoạt động với bất kỳ trợ lý AI cho lập trình nào hỗ trợ custom system prompt hoặc project context. Một số lựa chọn phổ biến:
 - **[Claude Code](https://code.claude.com)** — Công cụ CLI của Anthropic (khuyến nghị)
 - **[Cursor](https://cursor.sh)** — Trình soạn thảo mã lấy AI làm trung tâm
 - **[Codex CLI](https://github.com/openai/codex)** — Agent lập trình trên terminal của OpenAI
 Bạn nên quen với các khái niệm phát triển phần mềm cơ bản như quản lý phiên bản, cấu trúc dự án, và workflow Agile. Không cần có kinh nghiệm trước với các hệ thống agent kiểu BMad, vì bộ tài liệu này được viết ra chính để hỗ trợ việc đó.
 ## Tham gia cộng đồng
 Nhận trợ giúp, chia sẻ những gì bạn đang xây dựng, hoặc đóng góp cho BMad:
 - **[Discord](https://discord.gg/gk8jAdXWmj)** — Trao đổi với những người dùng BMad khác, đặt câu hỏi, chia sẻ ý tưởng
 - **[GitHub](https://github.com/bmad-code-org/BMAD-METHOD)** — Mã nguồn, issues, và đóng góp
 - **[YouTube](https://www.youtube.com/@BMadCode)** — Video hướng dẫn và walkthrough
 ## Bước tiếp theo
 Sẵn sàng bắt đầu? **[Bắt đầu với BMad](./tutorials/getting-started.md)** và xây dựng dự án đầu tiên của bạn.
--- a/docs/vi-vn/reference/agents.md
+++ b/docs/vi-vn/reference/agents.md
@ -0,0 +1,55 @@
 ---
 title: Agents
 description: Các agent mặc định của BMM cùng skill ID, trigger menu và workflow chính
 sidebar:
  order: 2
 ---
 ## Các Agent Mặc Định
 Trang này liệt kê các agent mặc định của BMM (bộ Agile suite) được cài cùng với BMad Method, bao gồm skill ID, trigger menu và workflow chính của chúng. Mỗi agent được gọi dưới dạng một skill.
 ## Ghi Chú
 - Mỗi agent đều có sẵn dưới dạng một skill do trình cài đặt tạo ra. Skill ID, ví dụ `bmad-dev`, được dùng để gọi agent.
 - Trigger là các mã menu ngắn, ví dụ `CP`, cùng với các fuzzy match hiển thị trong menu của từng agent.
 - Việc tạo test QA do workflow skill `bmad-qa-generate-e2e-tests` đảm nhận, khả dụng thông qua Developer agent. Module Test Architect (TEA) đầy đủ nằm trong một module riêng.
 | Agent | Skill ID | Trigger | Workflow chính |
 | --------------------------- | -------------------- | ---------------------------------- | --------------------------------------------------------------------------------------------------- |
 | Analyst (Mary) | `bmad-analyst` | `BP`, `RS`, `CB`, `WB`, `DP` | Brainstorm Project, Research, Create Brief, PRFAQ Challenge, Document Project |
 | Product Manager (John) | `bmad-pm` | `CP`, `VP`, `EP`, `CE`, `IR`, `CC` | Create/Validate/Edit PRD, Create Epics and Stories, Implementation Readiness, Correct Course |
 | Architect (Winston) | `bmad-architect` | `CA`, `IR` | Create Architecture, Implementation Readiness |
 | Developer (Amelia) | `bmad-agent-dev` | `DS`, `QD`, `QA`, `CR`, `SP`, `CS`, `ER` | Dev Story, Quick Dev, QA Test Generation, Code Review, Sprint Planning, Create Story, Epic Retrospective |
 | UX Designer (Sally) | `bmad-ux-designer` | `CU` | Create UX Design |
 | Technical Writer (Paige) | `bmad-tech-writer` | `DP`, `WD`, `US`, `MG`, `VD`, `EC` | Document Project, Write Document, Update Standards, Mermaid Generate, Validate Doc, Explain Concept |
 ## Các Loại Trigger
 Trigger trong menu agent dùng hai kiểu gọi khác nhau. Biết trigger thuộc kiểu nào sẽ giúp bạn cung cấp đúng đầu vào.
 ### Trigger workflow (không cần tham số)
 Phần lớn trigger sẽ nạp một file workflow có cấu trúc. Bạn gõ mã trigger, agent sẽ bắt đầu workflow và nhắc bạn nhập thông tin ở từng bước.
 Ví dụ: `CP` (Create PRD), `DS` (Dev Story), `CA` (Create Architecture), `QD` (Quick Dev)
 ### Trigger hội thoại (cần tham số)
 Một số trigger sẽ mở cuộc hội thoại tự do thay vì chạy workflow có cấu trúc. Khi đó bạn cần mô tả yêu cầu của mình cùng với mã trigger.
 | Agent | Trigger | Nội dung cần cung cấp |
 | --- | --- | --- |
 | Technical Writer (Paige) | `WD` | Mô tả tài liệu cần viết |
 | Technical Writer (Paige) | `US` | Sở thích hoặc quy ước muốn thêm vào standards |
 | Technical Writer (Paige) | `MG` | Mô tả sơ đồ và loại sơ đồ (sequence, flowchart, v.v.) |
 | Technical Writer (Paige) | `VD` | Tài liệu cần kiểm tra và các vùng trọng tâm |
 | Technical Writer (Paige) | `EC` | Tên khái niệm cần giải thích |
 **Ví dụ:**
 ```text
 WD Write a deployment guide for our Docker setup
 MG Create a sequence diagram showing the auth flow
 EC Explain how the module system works
 ```
--- a/docs/vi-vn/reference/commands.md
+++ b/docs/vi-vn/reference/commands.md
@ -0,0 +1,135 @@
 ---
 title: Skills
 description: Tài liệu tham chiếu cho skill của BMad — skill là gì, hoạt động ra sao và tìm ở đâu.
 sidebar:
  order: 3
 ---
 Skills là các prompt dựng sẵn để nạp agent, chạy workflow hoặc thực thi task bên trong IDE của bạn. Trình cài đặt BMad sinh chúng từ các module bạn đã chọn tại thời điểm cài đặt. Nếu sau này bạn thêm, xóa hoặc thay đổi module, hãy chạy lại trình cài đặt để đồng bộ skills (xem [Khắc phục sự cố](#khắc-phục-sự-cố)).
 ## Skill So Với Trigger Trong Menu Agent
 BMad cung cấp hai cách để bắt đầu công việc, và chúng phục vụ những mục đích khác nhau.
 | Cơ chế | Cách gọi | Điều xảy ra |
 | --- | --- | --- |
 | **Skill** | Gõ tên skill, ví dụ `bmad-help`, trong IDE | Nạp trực tiếp agent, chạy workflow hoặc thực thi task |
 | **Trigger menu agent** | Nạp agent trước, sau đó gõ mã ngắn như `DS` | Agent diễn giải mã đó và bắt đầu workflow tương ứng trong khi vẫn giữ đúng persona |
 Trigger trong menu agent yêu cầu bạn đang ở trong một phiên agent đang hoạt động. Dùng skill khi bạn đã biết mình muốn workflow nào. Dùng trigger khi bạn đang làm việc với một agent và muốn đổi tác vụ mà không rời khỏi cuộc hội thoại.
 ## Skills Được Tạo Ra Như Thế Nào
 Khi bạn chạy `npx bmad-method install`, trình cài đặt sẽ đọc manifest của mọi module được chọn rồi tạo một skill cho mỗi agent, workflow, task và tool. Mỗi skill là một thư mục chứa file `SKILL.md`, hướng dẫn AI nạp file nguồn tương ứng và làm theo chỉ dẫn trong đó.
 Trình cài đặt dùng template cho từng loại skill:
 | Loại skill | File được tạo sẽ làm gì |
 | --- | --- |
 | **Agent launcher** | Nạp file persona của agent, kích hoạt menu của nó và giữ nguyên vai trò |
 | **Workflow skill** | Nạp cấu hình workflow và làm theo các bước |
 | **Task skill** | Nạp một file task độc lập và làm theo hướng dẫn |
 | **Tool skill** | Nạp một file tool độc lập và làm theo hướng dẫn |
 :::note[Chạy lại trình cài đặt]
 Nếu bạn thêm hoặc bớt module, hãy chạy lại trình cài đặt. Nó sẽ tạo lại toàn bộ file skill khớp với tập module hiện tại.
 :::
 ## File Skill Nằm Ở Đâu
 Trình cài đặt sẽ ghi file skill vào một thư mục dành riêng cho IDE bên trong dự án. Đường dẫn chính xác phụ thuộc vào IDE bạn chọn khi cài.
 | IDE / CLI | Thư mục skill |
 | --- | --- |
 | Claude Code | `.claude/skills/` |
 | Cursor | `.cursor/skills/` |
 | Windsurf | `.windsurf/skills/` |
 | IDE khác | Xem output của trình cài đặt để biết đường dẫn đích |
 Mỗi skill là một thư mục chứa file `SKILL.md`. Ví dụ với Claude Code, cấu trúc sẽ như sau:
 ```text
 .claude/skills/
 ├── bmad-help/
 │   └── SKILL.md
 ├── bmad-create-prd/
 │   └── SKILL.md
 ├── bmad-agent-dev/
 │   └── SKILL.md
 └── ...
 ```
 Tên thư mục quyết định tên skill trong IDE. Ví dụ thư mục `bmad-agent-dev/` sẽ đăng ký skill `bmad-agent-dev`.
 ## Cách Tìm Danh Sách Skill Của Bạn
 Gõ tên skill trong IDE để gọi nó. Một số nền tảng yêu cầu bạn bật skills trong phần cài đặt trước khi chúng xuất hiện.
 Chạy `bmad-help` để nhận hướng dẫn có ngữ cảnh về bước tiếp theo.
 :::tip[Khám phá nhanh]
 Các thư mục skill được tạo trong dự án chính là danh sách chuẩn nhất. Mở chúng trong trình quản lý file để xem toàn bộ skill cùng mô tả.
 :::
 ## Các Nhóm Skill
 ### Agent Skills
 Agent skills nạp một persona AI chuyên biệt với vai trò, phong cách giao tiếp và menu workflow xác định sẵn. Sau khi được nạp, agent sẽ giữ đúng vai trò và phản hồi qua các trigger trong menu.
 | Ví dụ skill | Agent | Vai trò |
 | --- | --- | --- |
 | `bmad-agent-dev` | Amelia (Developer) | Triển khai story với mức tuân thủ đặc tả nghiêm ngặt |
 | `bmad-pm` | John (Product Manager) | Tạo và kiểm tra PRD |
 | `bmad-architect` | Winston (Architect) | Thiết kế kiến trúc hệ thống |
 Xem [Agents](./agents.md) để biết danh sách đầy đủ các agent mặc định và trigger của chúng.
 ### Workflow Skills
 Workflow skills chạy một quy trình có cấu trúc, nhiều bước mà không cần nạp persona agent trước. Chúng nạp cấu hình workflow rồi thực hiện theo từng bước.
 | Ví dụ skill | Mục đích |
 | --- | --- |
 | `bmad-product-brief` | Tạo product brief — phiên discovery có hướng dẫn khi concept của bạn đã rõ |
 | `bmad-prfaq` | Bài kiểm tra Working Backwards PRFAQ để stress-test concept sản phẩm |
 | `bmad-create-prd` | Tạo Product Requirements Document |
 | `bmad-create-architecture` | Thiết kế kiến trúc hệ thống |
 | `bmad-create-epics-and-stories` | Tạo epics và stories |
 | `bmad-dev-story` | Triển khai một story |
 | `bmad-code-review` | Chạy code review |
 | `bmad-quick-dev` | Luồng nhanh hợp nhất — làm rõ yêu cầu, lập kế hoạch, triển khai, review và trình bày |
 Xem [Workflow Map](./workflow-map.md) để có tài liệu workflow đầy đủ theo từng phase.
 ### Task Skills Và Tool Skills
 Tasks và tools là các thao tác độc lập, không yêu cầu ngữ cảnh agent hay workflow.
 **BMad-Help: người dẫn đường thông minh của bạn**
 `bmad-help` là giao diện chính để bạn khám phá nên làm gì tiếp theo. Nó kiểm tra dự án, hiểu truy vấn ngôn ngữ tự nhiên và đề xuất bước bắt buộc hoặc tùy chọn tiếp theo dựa trên các module đã cài.
 :::note[Ví dụ]
 ```text
 bmad-help
 bmad-help I have a SaaS idea and know all the features. Where do I start?
 bmad-help What are my options for UX design?
 ```
 :::
 **Các task và tool lõi khác**
 Module lõi có 11 công cụ tích hợp sẵn — review, nén tài liệu, brainstorming, quản lý tài liệu và nhiều hơn nữa. Xem [Core Tools](./core-tools.md) để có tài liệu tham chiếu đầy đủ.
 ## Quy Ước Đặt Tên
 Mọi skill đều dùng tiền tố `bmad-` theo sau là tên mô tả, ví dụ `bmad-agent-dev`, `bmad-create-prd`, `bmad-help`. Xem [Modules](./modules.md) để biết các module hiện có.
 ## Khắc Phục Sự Cố
 **Skills không xuất hiện sau khi cài đặt.** Một số nền tảng yêu cầu bật skills thủ công trong phần cài đặt. Hãy kiểm tra tài liệu IDE của bạn hoặc hỏi trợ lý AI cách bật skills. Bạn cũng có thể cần khởi động lại IDE hoặc reload cửa sổ.
 **Thiếu skill mà bạn mong đợi.** Trình cài đặt chỉ tạo skill cho những module bạn đã chọn. Hãy chạy lại `npx bmad-method install` và kiểm tra lại phần chọn module. Đồng thời xác nhận rằng file skill thực sự tồn tại trong thư mục dự kiến.
 **Skill từ module đã bỏ vẫn còn xuất hiện.** Trình cài đặt không tự xóa các file skill cũ. Hãy xóa các thư mục lỗi thời trong thư mục skills của IDE, hoặc xóa toàn bộ thư mục skills rồi chạy lại trình cài đặt để có tập skill sạch.
--- a/docs/vi-vn/reference/core-tools.md
+++ b/docs/vi-vn/reference/core-tools.md
@ -0,0 +1,293 @@
 ---
 title: Core Tools
 description: Tài liệu tham chiếu cho mọi task và workflow tích hợp sẵn có trong mọi bản cài BMad mà không cần module bổ sung.
 sidebar:
  order: 2
 ---
 Mọi bản cài BMad đều bao gồm một tập core skills có thể dùng cùng với bất cứ việc gì bạn đang làm — các task và workflow độc lập hoạt động xuyên suốt mọi dự án, mọi module và mọi phase. Chúng luôn có sẵn bất kể bạn cài những module tùy chọn nào.
 :::tip[Lối đi nhanh]
 Chạy bất kỳ core tool nào bằng cách gõ tên skill của nó, ví dụ `bmad-help`, trong IDE của bạn. Không cần mở phiên agent trước.
 :::
 ## Tổng Quan
 | Công cụ | Loại | Mục đích |
 | --- | --- | --- |
 | [`bmad-help`](#bmad-help) | Task | Nhận hướng dẫn có ngữ cảnh về việc nên làm gì tiếp theo |
 | [`bmad-brainstorming`](#bmad-brainstorming) | Workflow | Tổ chức các phiên brainstorming có tương tác |
 | [`bmad-party-mode`](#bmad-party-mode) | Workflow | Điều phối thảo luận nhóm nhiều agent |
 | [`bmad-distillator`](#bmad-distillator) | Task | Nén tài liệu tối ưu cho LLM mà không mất thông tin |
 | [`bmad-advanced-elicitation`](#bmad-advanced-elicitation) | Task | Đẩy đầu ra của LLM qua các vòng tinh luyện lặp |
 | [`bmad-review-adversarial-general`](#bmad-review-adversarial-general) | Task | Review hoài nghi để tìm chỗ thiếu và chỗ sai |
 | [`bmad-review-edge-case-hunter`](#bmad-review-edge-case-hunter) | Task | Phân tích toàn bộ nhánh rẽ để tìm edge case chưa được xử lý |
 | [`bmad-editorial-review-prose`](#bmad-editorial-review-prose) | Task | Biên tập câu chữ nhằm tăng độ rõ ràng khi giao tiếp |
 | [`bmad-editorial-review-structure`](#bmad-editorial-review-structure) | Task | Biên tập cấu trúc — cắt, gộp và tổ chức lại |
 | [`bmad-shard-doc`](#bmad-shard-doc) | Task | Tách file markdown lớn thành các phần có tổ chức |
 | [`bmad-index-docs`](#bmad-index-docs) | Task | Tạo hoặc cập nhật mục lục cho toàn bộ tài liệu trong một thư mục |
 ## bmad-help
 **Người dẫn đường thông minh cho bước tiếp theo của bạn.** Công cụ này kiểm tra trạng thái dự án, phát hiện những gì đã hoàn thành và đề xuất bước bắt buộc hoặc tùy chọn tiếp theo.
 **Dùng khi:**
 - Bạn vừa hoàn tất một workflow và muốn biết tiếp theo là gì
 - Bạn mới làm quen với BMad và cần định hướng
 - Bạn đang mắc kẹt và muốn lời khuyên có ngữ cảnh
 - Bạn vừa cài module mới và muốn xem có gì khả dụng
 **Cách hoạt động:**
 1. Quét dự án để tìm các artifact hiện có như PRD, architecture, stories, v.v.
 2. Phát hiện các module đã cài và workflow khả dụng của chúng
 3. Đề xuất bước tiếp theo theo thứ tự ưu tiên — bước bắt buộc trước, tùy chọn sau
 4. Trình bày từng đề xuất cùng lệnh skill và mô tả ngắn
 **Đầu vào:** Truy vấn ngôn ngữ tự nhiên tùy chọn, ví dụ `bmad-help I have a SaaS idea, where do I start?`
 **Đầu ra:** Danh sách ưu tiên các bước tiếp theo được khuyến nghị kèm lệnh skill
 ## bmad-brainstorming
 **Tạo ra nhiều ý tưởng đa dạng bằng các kỹ thuật sáng tạo có tương tác.** Đây là một phiên brainstorming có điều phối, nạp các phương pháp phát ý tưởng đã được kiểm chứng từ thư viện kỹ thuật và dẫn bạn đến 100+ ý tưởng trước khi bắt đầu sắp xếp.
 **Dùng khi:**
 - Bạn đang bắt đầu một dự án mới và cần khám phá không gian vấn đề
 - Bạn đang bí ý tưởng và cần một quy trình sáng tạo có cấu trúc
 - Bạn muốn dùng các framework tạo ý tưởng đã được kiểm chứng như SCAMPER, reverse brainstorming, v.v.
 **Cách hoạt động:**
 1. Thiết lập phiên brainstorming theo chủ đề của bạn
 2. Nạp các kỹ thuật sáng tạo từ thư viện phương pháp
 3. Dẫn bạn đi qua từng kỹ thuật để tạo ý tưởng
 4. Áp dụng giao thức chống thiên lệch — cứ mỗi 10 ý tưởng lại đổi miền sáng tạo để tránh gom cụm
 5. Tạo một tài liệu phiên làm việc chỉ thêm vào, trong đó mọi ý tưởng được tổ chức theo kỹ thuật
 **Đầu vào:** Chủ đề brainstorming hoặc phát biểu vấn đề, cùng file context tùy chọn
 **Đầu ra:** `brainstorming-session-{date}.md` chứa toàn bộ ý tưởng được tạo ra
 :::note[Mục tiêu về số lượng]
 Điểm bứt phá thường nằm ở vùng ý tưởng thứ 50-100. Workflow này khuyến khích bạn tạo 100+ ý tưởng trước khi sắp xếp.
 :::
 ## bmad-party-mode
 **Điều phối thảo luận nhóm nhiều agent.** Công cụ này nạp toàn bộ agent BMad đã cài và tạo một cuộc trao đổi tự nhiên, nơi mỗi agent đóng góp từ góc nhìn chuyên môn và cá tính riêng.
 **Dùng khi:**
 - Bạn cần nhiều góc nhìn chuyên gia cho một quyết định
 - Bạn muốn các agent phản biện giả định của nhau
 - Bạn đang khám phá một chủ đề phức tạp trải qua nhiều miền khác nhau
 **Cách hoạt động:**
 1. Nạp manifest agent chứa toàn bộ persona đã cài
 2. Phân tích chủ đề của bạn để chọn ra 2-3 agent phù hợp nhất
 3. Các agent lần lượt tham gia, có tương tác chéo và bất đồng tự nhiên
 4. Luân phiên agent để đảm bảo góc nhìn đa dạng theo thời gian
 5. Kết thúc bằng `goodbye`, `end party` hoặc `quit`
 **Đầu vào:** Chủ đề hoặc câu hỏi thảo luận, cùng thông tin về các persona bạn muốn tham gia nếu có
 **Đầu ra:** Cuộc hội thoại nhiều agent theo thời gian thực, vẫn giữ nguyên cá tính từng agent
 ## bmad-distillator
 **Nén tài liệu nguồn tối ưu cho LLM mà không mất thông tin.** Công cụ này tạo ra các bản chưng cất dày đặc, tiết kiệm token nhưng vẫn giữ nguyên toàn bộ thông tin cho LLM dùng về sau. Có thể xác minh bằng tái dựng hai chiều.
 **Dùng khi:**
 - Một tài liệu quá lớn so với context window của LLM
 - Bạn cần phiên bản tiết kiệm token của tài liệu nghiên cứu, đặc tả hoặc artifact lập kế hoạch
 - Bạn muốn xác minh rằng không có thông tin nào bị mất trong quá trình nén
 - Các agent sẽ cần tham chiếu và tìm thông tin trong đó thường xuyên
 **Cách hoạt động:**
 1. **Analyze** — Đọc tài liệu nguồn, nhận diện mật độ thông tin và cấu trúc
 2. **Compress** — Chuyển văn xuôi thành dạng bullet dày đặc, bỏ trang trí không cần thiết
 3. **Verify** — Kiểm tra tính đầy đủ để đảm bảo mọi thông tin gốc còn nguyên
 4. **Validate** *(tùy chọn)* — Tái dựng hai chiều để chứng minh nén không mất mát
 **Đầu vào:**
 - `source_documents` *(bắt buộc)* — Đường dẫn file, thư mục hoặc mẫu glob
 - `downstream_consumer` *(tùy chọn)* — Thành phần sẽ dùng đầu ra này, ví dụ "PRD creation"
 - `token_budget` *(tùy chọn)* — Kích thước mục tiêu gần đúng
 - `--validate` *(cờ)* — Chạy kiểm tra tái dựng hai chiều
 **Đầu ra:** Một hoặc nhiều file markdown distillate kèm báo cáo tỷ lệ nén, ví dụ `3.2:1`
 ## bmad-advanced-elicitation
 **Đẩy đầu ra của LLM qua các phương pháp tinh luyện lặp.** Công cụ này chọn từ thư viện kỹ thuật elicitation để cải thiện nội dung một cách có hệ thống qua nhiều lượt.
 **Dùng khi:**
 - Đầu ra của LLM còn nông hoặc quá chung chung
 - Bạn muốn khám phá một chủ đề từ nhiều góc phân tích khác nhau
 - Bạn đang tinh chỉnh một tài liệu quan trọng và cần chiều sâu hơn
 **Cách hoạt động:**
 1. Nạp registry phương pháp với hơn 5 kỹ thuật elicitation
 2. Chọn ra 5 phương pháp phù hợp nhất dựa trên loại nội dung và độ phức tạp
 3. Hiển thị menu tương tác — chọn một phương pháp, xáo lại, hoặc liệt kê tất cả
 4. Áp dụng phương pháp đã chọn để nâng cấp nội dung
 5. Tiếp tục đưa ra lựa chọn cho các vòng cải thiện tiếp theo cho đến khi bạn chọn "Proceed"
 **Đầu vào:** Phần nội dung cần cải thiện
 **Đầu ra:** Phiên bản nội dung đã được nâng cấp
 ## bmad-review-adversarial-general
 **Kiểu review hoài nghi, mặc định cho rằng vấn đề luôn tồn tại và phải đi tìm chúng.** Công cụ này đứng ở góc nhìn của một reviewer khó tính, thiếu kiên nhẫn với sản phẩm cẩu thả. Nó tìm xem còn thiếu gì, không chỉ tìm cái gì sai.
 **Dùng khi:**
 - Bạn cần bảo đảm chất lượng trước khi chốt một deliverable
 - Bạn muốn stress-test một spec, story hoặc tài liệu
 - Bạn muốn tìm lỗ hổng bao phủ mà các review lạc quan thường bỏ sót
 **Cách hoạt động:**
 1. Đọc nội dung với góc nhìn hoài nghi và khắt khe
 2. Xác định vấn đề về độ đầy đủ, độ đúng và chất lượng
 3. Chủ động tìm phần còn thiếu chứ không chỉ phần hiện diện nhưng sai
 4. Phải tìm được tối thiểu 10 vấn đề, nếu không sẽ phân tích sâu hơn
 **Đầu vào:**
 - `content` *(bắt buộc)* — Diff, spec, story, tài liệu hoặc bất kỳ artifact nào
 - `also_consider` *(tùy chọn)* — Các vùng bổ sung cần để ý
 **Đầu ra:** Danh sách markdown gồm 10+ phát hiện kèm mô tả
 ## bmad-review-edge-case-hunter
 **Đi qua mọi nhánh rẽ và điều kiện biên, chỉ báo cáo những trường hợp chưa được xử lý.** Đây là phương pháp thuần túy dựa trên truy vết đường đi, suy ra các lớp edge case một cách cơ học. Nó trực giao với adversarial review — khác phương pháp, không khác thái độ.
 **Dùng khi:**
 - Bạn muốn bao phủ edge case toàn diện cho code hoặc logic
 - Bạn cần một phương pháp bổ sung cho adversarial review
 - Bạn đang review diff hoặc function để tìm điều kiện biên
 **Cách hoạt động:**
 1. Liệt kê toàn bộ nhánh rẽ trong nội dung
 2. Suy ra cơ học các lớp edge case: thiếu else/default, input không được gác, off-by-one, tràn số học, ép kiểu ngầm, race condition, lỗ hổng timeout
 3. Đối chiếu từng đường đi với các guard hiện có
 4. Chỉ báo cáo các đường đi chưa được xử lý, âm thầm bỏ qua những trường hợp đã được che chắn
 **Đầu vào:**
 - `content` *(bắt buộc)* — Diff, toàn file hoặc function
 - `also_consider` *(tùy chọn)* — Các vùng bổ sung cần lưu ý
 **Đầu ra:** Mảng JSON các phát hiện, mỗi phát hiện có `location`, `trigger_condition`, `guard_snippet` và `potential_consequence`
 :::note[Các kiểu review bổ trợ nhau]
 Hãy chạy cả `bmad-review-adversarial-general` và `bmad-review-edge-case-hunter` để có độ bao phủ trực giao. Adversarial review bắt lỗi về chất lượng và độ đầy đủ; edge case hunter bắt các đường đi chưa được xử lý.
 :::
 ## bmad-editorial-review-prose
 **Biên tập câu chữ kiểu lâm sàng, tập trung vào độ rõ ràng khi truyền đạt.** Công cụ này review văn bản để tìm ra các vấn đề cản trở việc hiểu. Nó dùng Microsoft Writing Style Guide làm nền và vẫn giữ giọng văn của tác giả.
 **Dùng khi:**
 - Bạn đã có bản nháp tài liệu và muốn trau chuốt câu chữ
 - Bạn cần đảm bảo độ rõ ràng cho một nhóm độc giả cụ thể
 - Bạn muốn sửa lỗi giao tiếp mà không áp đặt gu phong cách cá nhân
 **Cách hoạt động:**
 1. Đọc nội dung, bỏ qua code block và frontmatter
 2. Xác định các vấn đề cản trở hiểu nghĩa, không phải các sở thích phong cách
 3. Khử trùng lặp những lỗi giống nhau xuất hiện nhiều nơi
 4. Tạo bảng sửa lỗi ba cột
 **Đầu vào:**
 - `content` *(bắt buộc)* — Markdown, văn bản thường hoặc XML
 - `style_guide` *(tùy chọn)* — Style guide riêng của dự án
 - `reader_type` *(tùy chọn)* — `humans` mặc định cho độ rõ và nhịp đọc, hoặc `llm` cho độ chính xác và nhất quán
 **Đầu ra:** Bảng markdown ba cột: Original Text | Revised Text | Changes
 ## bmad-editorial-review-structure
 **Biên tập cấu trúc — đề xuất cắt, gộp, di chuyển và cô đọng.** Công cụ này review cách tổ chức tài liệu và đề xuất thay đổi mang tính nội dung để tăng độ rõ ràng và luồng đọc trước khi chỉnh câu chữ.
 **Dùng khi:**
 - Một tài liệu được ghép từ nhiều nguồn con và cần tính nhất quán về cấu trúc
 - Bạn muốn rút gọn độ dài tài liệu nhưng vẫn giữ được khả năng hiểu
 - Bạn cần phát hiện chỗ lệch phạm vi hoặc thông tin quan trọng bị chôn vùi
 **Cách hoạt động:**
 1. Phân tích tài liệu theo 5 mô hình cấu trúc: Tutorial, Reference, Explanation, Prompt, Strategic
 2. Xác định phần dư thừa, lệch phạm vi và thông tin bị chìm
 3. Tạo danh sách khuyến nghị theo mức ưu tiên: CUT, MERGE, MOVE, CONDENSE, QUESTION, PRESERVE
 4. Ước tính số từ và phần trăm có thể giảm
 **Đầu vào:**
 - `content` *(bắt buộc)* — Tài liệu cần review
 - `purpose` *(tùy chọn)* — Mục đích mong muốn, ví dụ "quickstart tutorial"
 - `target_audience` *(tùy chọn)* — Ai sẽ đọc tài liệu này
 - `reader_type` *(tùy chọn)* — `humans` hoặc `llm`
 - `length_target` *(tùy chọn)* — Mục tiêu rút gọn, ví dụ "ngắn hơn 30%"
 **Đầu ra:** Tóm tắt tài liệu, danh sách khuyến nghị ưu tiên và ước tính mức giảm
 ## bmad-shard-doc
 **Tách file markdown lớn thành các file phần có tổ chức.** Công cụ này dùng các header cấp 2 làm điểm cắt để tạo ra một thư mục gồm các file phần tự chứa cùng một file chỉ mục.
 **Dùng khi:**
 - Một file markdown đã quá lớn để quản lý hiệu quả, thường trên 500 dòng
 - Bạn muốn chia một tài liệu nguyên khối thành các phần dễ điều hướng
 - Bạn cần các file riêng để chỉnh sửa song song hoặc quản lý context cho LLM
 **Cách hoạt động:**
 1. Xác nhận file nguồn tồn tại và là markdown
 2. Tách tại các header cấp 2 `##` thành các file phần được đánh số
 3. Tạo `index.md` chứa danh sách phần và liên kết
 4. Hỏi bạn có muốn xóa, lưu trữ hay giữ file gốc không
 **Đầu vào:** Đường dẫn file markdown nguồn, cùng thư mục đích tùy chọn
 **Đầu ra:** Một thư mục gồm `index.md` và các file `01-{section}.md`, `02-{section}.md`, v.v.
 ## bmad-index-docs
 **Tạo hoặc cập nhật mục lục cho toàn bộ tài liệu trong một thư mục.** Công cụ này quét thư mục, đọc từng file để hiểu mục đích của nó, rồi tạo `index.md` có tổ chức với liên kết và mô tả.
 **Dùng khi:**
 - Bạn cần một chỉ mục nhẹ để LLM quét nhanh các tài liệu hiện có
 - Một thư mục tài liệu đã lớn và cần bảng mục lục có tổ chức
 - Bạn muốn một cái nhìn tổng quan được tạo tự động và luôn theo kịp hiện trạng
 **Cách hoạt động:**
 1. Quét thư mục đích để lấy mọi file không ẩn
 2. Đọc từng file để hiểu đúng mục đích thực tế của nó
 3. Nhóm file theo loại, mục đích hoặc thư mục con
 4. Tạo mô tả ngắn gọn, thường từ 3-10 từ cho mỗi file
 **Đầu vào:** Đường dẫn thư mục đích
 **Đầu ra:** `index.md` chứa danh sách file có tổ chức, liên kết tương đối và mô tả ngắn
--- a/docs/vi-vn/reference/modules.md
+++ b/docs/vi-vn/reference/modules.md
@ -0,0 +1,76 @@
 ---
 title: Các Module Chính Thức
 description: Các module bổ sung để xây agent tùy chỉnh, tăng cường sáng tạo, phát triển game và kiểm thử
 sidebar:
  order: 4
 ---
 BMad được mở rộng thông qua các module chính thức mà bạn chọn trong quá trình cài đặt. Những module bổ sung này cung cấp agent, workflow và task chuyên biệt cho các lĩnh vực cụ thể, vượt ra ngoài phần lõi tích hợp sẵn và BMM (Agile suite).
 :::tip[Cài đặt module]
 Chạy `npx bmad-method install` rồi chọn những module bạn muốn. Trình cài đặt sẽ tự xử lý phần tải về, cấu hình và tích hợp vào IDE.
 :::
 ## BMad Builder
 Tạo agent tùy chỉnh, workflow tùy chỉnh và module chuyên biệt theo lĩnh vực với sự hỗ trợ có hướng dẫn. BMad Builder là meta-module để mở rộng chính framework này.
 - **Mã:** `bmb`
 - **npm:** [`bmad-builder`](https://www.npmjs.com/package/bmad-builder)
 - **GitHub:** [bmad-code-org/bmad-builder](https://github.com/bmad-code-org/bmad-builder)
 **Cung cấp:**
 - Agent Builder — tạo AI agent chuyên biệt với chuyên môn và quyền truy cập công cụ tùy chỉnh
 - Workflow Builder — thiết kế quy trình có cấu trúc với các bước và điểm quyết định
 - Module Builder — đóng gói agent và workflow thành các module có thể chia sẻ và phát hành
 - Thiết lập có tương tác bằng YAML cùng hỗ trợ publish lên npm
 ## Creative Intelligence Suite
 Bộ công cụ vận hành bởi AI dành cho sáng tạo có cấu trúc, phát ý tưởng và đổi mới trong giai đoạn đầu phát triển. Bộ này cung cấp nhiều agent giúp brainstorming, design thinking và giải quyết vấn đề bằng các framework đã được kiểm chứng.
 - **Mã:** `cis`
 - **npm:** [`bmad-creative-intelligence-suite`](https://www.npmjs.com/package/bmad-creative-intelligence-suite)
 - **GitHub:** [bmad-code-org/bmad-module-creative-intelligence-suite](https://github.com/bmad-code-org/bmad-module-creative-intelligence-suite)
 **Cung cấp:**
 - Các agent Innovation Strategist, Design Thinking Coach và Brainstorming Coach
 - Problem Solver và Creative Problem Solver cho tư duy hệ thống và tư duy bên lề
 - Storyteller và Presentation Master cho kể chuyện và pitching
 - Các framework phát ý tưởng như SCAMPER, Reverse Brainstorming và problem reframing
 ## Game Dev Studio
 Các workflow phát triển game có cấu trúc, được điều chỉnh cho Unity, Unreal, Godot và các engine tùy chỉnh. Hỗ trợ làm prototype nhanh qua Quick Flow và sản xuất toàn diện bằng sprint theo epic.
 - **Mã:** `gds`
 - **npm:** [`bmad-game-dev-studio`](https://www.npmjs.com/package/bmad-game-dev-studio)
 - **GitHub:** [bmad-code-org/bmad-module-game-dev-studio](https://github.com/bmad-code-org/bmad-module-game-dev-studio)
 **Cung cấp:**
 - Workflow tạo Game Design Document (GDD)
 - Chế độ Quick Dev cho làm prototype nhanh
 - Hỗ trợ thiết kế narrative cho nhân vật, hội thoại và world-building
 - Bao phủ hơn 21 thể loại game cùng hướng dẫn kiến trúc theo engine
 ## Test Architect (TEA)
 Chiến lược kiểm thử cấp doanh nghiệp, hướng dẫn tự động hóa và quyết định release gate thông qua một agent chuyên gia cùng chín workflow có cấu trúc. TEA vượt xa QA agent tích hợp sẵn nhờ ưu tiên theo rủi ro và truy vết yêu cầu.
 - **Mã:** `tea`
 - **npm:** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
 - **GitHub:** [bmad-code-org/bmad-method-test-architecture-enterprise](https://github.com/bmad-code-org/bmad-method-test-architecture-enterprise)
 **Cung cấp:**
 - Agent Murat (Master Test Architect and Quality Advisor)
 - Các workflow cho test design, ATDD, automation, test review và traceability
 - Đánh giá NFR, thiết lập CI và dựng sườn framework kiểm thử
 - Ưu tiên P0-P3 cùng tích hợp tùy chọn với Playwright Utils và MCP
 ## Community Modules
 Các module cộng đồng và một chợ module đang được chuẩn bị. Hãy theo dõi [tổ chức BMad trên GitHub](https://github.com/bmad-code-org) để cập nhật.
--- a/docs/vi-vn/reference/testing.md
+++ b/docs/vi-vn/reference/testing.md
@ -0,0 +1,106 @@
 ---
 title: Các Tùy Chọn Kiểm Thử
 description: So sánh workflow QA tích hợp sẵn với module Test Architect (TEA) cho tự động hóa kiểm thử.
 sidebar:
  order: 5
 ---
 BMad cung cấp hai hướng kiểm thử: workflow QA tích hợp sẵn để tạo test nhanh và module Test Architect có thể cài thêm cho chiến lược kiểm thử c<><63>p doanh nghiệp.
 ## Nên Dùng Cái Nào?
 | Yếu tố | QA tích hợp sẵn | Module TEA |
 | --- | --- | --- |
 | **Phù hợp nhất với** | Dự án nhỏ-trung bình, cần bao phủ nhanh | Dự án lớn, miền nghiệp vụ bị ràng buộc hoặc phức tạp |
 | **Thiết lập** | Không cần cài thêm, đã có sẵn trong BMM | Cài riêng qua `npx bmad-method install` |
 | **Cách tiếp cận** | Tạo test nhanh, lặp tinh chỉnh sau | Lập kế hoạch trước rồi mới tạo test có truy vết |
 | **Loại test** | API và E2E | API, E2E, ATDD, NFR và nhiều loại khác |
 | **Chiến lược** | Happy path + edge case quan trọng | Ưu tiên theo rủi ro (P0-P3) |
 | **Số workflow** | 1 (Automate) | 9 (design, ATDD, automate, review, trace và các workflow khác) |
 :::tip[Bắt đầu với QA tích h<><68>p sẵn]
 Phần lớn dự án nên bắt đầu với workflow QA tích hợp sẵn. Nếu sau này bạn cần chiến lược kiểm thử, quality gate hoặc truy vết yêu cầu, hãy cài TEA song song.
 :::
 ## Workflow QA Tích Hợp Sẵn
 Workflow QA tích hợp sẵn (`bmad-qa-generate-e2e-tests`) nằm trong module BMM (Agile suite), khả dụng thông qua Developer agent. Nó tạo test chạy được rất nhanh bằng framework kiểm thử hiện có của dự án, không cần thêm cấu hình hay bước cài đặt bổ sung.
 **Trigger:** `QA` (thông qua Developer agent) hoặc `bmad-qa-generate-e2e-tests`
 ### Workflow Làm Gì
 Workflow QA (Automate) gồm năm bước:
 1. **Phát hiện framework test** — quét `package.json` và các file test hiện có để nhận ra framework của bạn như Jest, Vitest, Playwright, Cypress hoặc bất kỳ runner tiêu chuẩn nào. Nếu chưa có gì, nó sẽ phân tích stack dự án và đề xuất một lựa chọn.
 2. **Xác định tính năng** — hỏi cần kiểm thử phần nào hoặc tự khám phá các tính năng trong codebase.
 3. **Tạo API tests** — bao phủ status code, cấu trúc phản hồi, happy path và 1-2 trường hợp lỗi.
 4. **Tạo E2E tests** — bao phủ workflow người dùng bằng semantic locator và assertion trên kết quả nhìn thấy được.
 5. **Chạy và xác minh** — thực thi test vừa tạo và sửa lỗi hỏng ngay lập tức.
 Workflow tạo một bản tóm tắt kiểm thử và lưu nó vào thư mục implementation artifacts của dự án.
 ### Mẫu Kiểm Thử
 Các test được tạo theo triết lý “đơn giản và dễ bảo trì”:
 - **Chỉ dùng API chuẩn của framework** — không kéo thêm utility ngoài hay abstraction tùy chỉnh
 - **Semantic locator** cho UI test — dùng role, label, text thay vì CSS selector
 - **Test độc lập** — không phụ thuộc thứ tự chạy
 - **Không hardcode wait hoặc sleep**
 - **Mô tả rõ ràng** để test cũng đóng vai trò tài liệu tính năng
 :::note[Phạm vi]
 Workflow QA chỉ tạo test. Nếu bạn cần code review hoặc xác nhận story, hãy dùng workflow Code Review (`CR`).
 :::
 ### Khi Nào Nên Dùng QA Tích Hợp S<><53><EFBFBD>n
 - Cần bao phủ test nhanh cho một tính năng mới hoặc hiện có
 - Muốn tự động hóa kiểm thử thân thiện với người mới mà không cần thiết lập phức tạp
 - Muốn các pattern test chuẩn mà lập trình viên nào cũng đọc và bảo trì được
 - Dự án nhỏ-trung bình, nơi chiến lược kiểm thử toàn diện là không cần thiết
 ## Module Test Architect (TEA)
 TEA là một module độc lập cung cấp agent chuyên gia Murat cùng chín workflow có cấu trúc cho kiểm thử cấp doanh nghiệp. Nó vượt ra ngoài việc tạo test để bao gồm chiến lược kiểm thử, lập kế hoạch theo rủi ro, quality gate và truy vết yêu cầu.
 - **Tài liệu:** [TEA Module Docs](https://bmad-code-org.github.io/bmad-method-test-architecture-enterprise/)
 - **Cài đặt:** `npx bmad-method install` rồi chọn module TEA
 - **npm:** [`bmad-method-test-architecture-enterprise`](https://www.npmjs.com/package/bmad-method-test-architecture-enterprise)
 ### TEA Cung Cấp Gì
 | Workflow | Mục đích |
 | --- | --- |
 | Test Design | Tạo chiến lược kiểm thử toàn diện gắn với yêu cầu |
 | ATDD | Phát triển hướng acceptance test với tiêu chí của stakeholder |
 | Automate | Tạo test bằng pattern và utility nâng cao |
 | Test Review | Kiểm tra chất lượng và độ bao phủ của test so với chiến lược |
 | Traceability | Liên kết test ngược về yêu cầu để phục vụ audit và tuân thủ |
 | NFR Assessment | Đánh giá các yêu cầu phi chức năng như hiệu năng, bảo mật |
 | CI Setup | Cấu hình thực thi test trong pipeline tích hợp liên tục |
 | Framework Scaffolding | Dựng hạ tầng và cấu trúc dự án kiểm thử |
 | Release Gate | Ra quyết định phát hành go/no-go dựa trên dữ liệu |
 TEA cũng hỗ trợ ưu tiên theo rủi ro P0-P3 và tích hợp tùy chọn với Playwright Utils cùng công cụ MCP.
 ### Khi Nào Nên Dùng TEA
 - Dự án cần truy vết yêu cầu hoặc tài liệu tuân thủ
 - Đội ngũ cần ưu tiên kiểm thử theo rủi ro trên nhiều tính năng
 - Môi trường doanh nghiệp có quality gate chính thức trước phát hành
 - Miền nghiệp vụ phức tạp, nơi chiến lược kiểm thử phải được lên trước khi viết test
 - Dự án đã vượt quá mô hình một workflow của QA tích hợp sẵn
 ## Kiểm Thử Nằm Ở Đâu Trong Workflow
 Workflow QA Automate xuất hiện ở Phase 4 (Implementation) trong workflow map của BMad Method. Nó được thiết kế để chạy **sau khi hoàn tất trọn vẹn một epic** — tức là khi mọi story trong epic đó đã được triển khai và code review xong. Trình tự điển hình là:
 1. Với mỗi story trong epic: triển khai bằng Dev (`DS`), sau đó xác nhận bằng Code Review (`CR`)
 2. Sau khi epic hoàn tất: tạo test bằng `QA` (thông qua Developer agent) hoặc workflow Automate của TEA
 3. Chạy retrospective (`bmad-retrospective`) để ghi nhận bài học rút ra
 Workflow QA tích hợp sẵn làm việc trực tiếp từ source code mà không cần nạp tài liệu lập kế hoạch như PRD hay architecture. Các workflow của TEA có thể tích hợp với artifact lập kế hoạch ở các bước trước để phục vụ truy vết.
 Để hiểu rõ hơn kiểm thử nằm ở đâu trong quy trình tổng thể, xem [Workflow Map](./workflow-map.md).
--- a/docs/vi-vn/reference/workflow-map.md
+++ b/docs/vi-vn/reference/workflow-map.md
@ -0,0 +1,89 @@
 ---
 title: "Workflow Map"
 description: Tài liệu trực quan về các phase workflow và output của BMad Method
 sidebar:
  order: 1
 ---
 BMad Method (BMM) là một module trong hệ sinh thái BMad, tập trung vào các thực hành tốt nhất của context engineering và lập kế hoạch. AI agent hoạt động hiệu quả nhất khi có ngữ cảnh rõ ràng và có cấu trúc. Hệ thống BMM xây dựng ngữ cảnh đó theo tiến trình qua 4 phase riêng biệt. Mỗi phase, cùng với nhiều workflow tùy chọn bên trong phase đó, tạo ra các tài liệu làm đầu vào cho phase kế tiếp, nhờ vậy agent luôn biết phải xây gì và vì sao.
 Lý do và các khái niệm nền tảng ở đây đến từ các phương pháp agile đã được áp dụng rất thành công trong toàn ngành như một khung tư duy.
 Nếu có lúc nào bạn không chắc nên làm gì, skill `bmad-help` sẽ giúp bạn giữ đúng hướng hoặc biết bước tiếp theo. Bạn vẫn có thể dùng trang này để tham chiếu, nhưng `bmad-help` mang tính tương tác đầy đủ và nhanh hơn nhiều nếu bạn đã cài BMad Method. Ngoài ra, nếu bạn đang dùng thêm các module mở rộng BMad Method hoặc các module bổ sung khác, `bmad-help` cũng sẽ phát triển theo để biết mọi thứ đang có sẵn và đưa ra lời khuyên tốt nhất tại thời điểm đó.
 Lưu ý quan trọng cuối cùng: mọi workflow dưới đây đều có thể chạy trực tiếp bằng công cụ bạn chọn thông qua skill, hoặc bằng cách nạp agent trước rồi chọn mục tương ứng trong menu agent.
 <iframe src="/workflow-map-diagram.html" title="Sơ đồ Workflow Map của BMad Method" width="100%" height="100%" style="border-radius: 8px; border: 1px solid #334155; min-height: 900px;"></iframe>
 <p style="font-size: 0.8rem; text-align: right; margin-top: -0.5rem; margin-bottom: 1rem;">
  <a href="/workflow-map-diagram.html" target="_blank" rel="noopener noreferrer">Mở sơ đồ trong tab mới ↗</a>
 </p>
 ## Phase 1: Analysis (Tùy chọn)
 Khám phá không gian vấn đề và xác nhận ý tưởng trước khi cam kết đi vào lập kế hoạch. [**Tìm hiểu từng công cụ làm gì và nên dùng khi nào**](../explanation/analysis-phase.md).
 | Workflow | Mục đích | Tạo ra |
 | ------------------------------- | -------------------------------------------------------------------------- | ------------------------- |
 | `bmad-brainstorming` | Brainstorm ý tưởng dự án với sự điều phối của brainstorming coach | `brainstorming-report.md` |
 | `bmad-domain-research`, `bmad-market-research`, `bmad-technical-research` | Xác thực giả định về thị trường, kỹ thuật hoặc miền nghiệp vụ | Kết quả nghiên cứu |
 | `bmad-product-brief` | Ghi lại tầm nhìn chiến lược — phù hợp nhất khi concept của bạn đã rõ | `product-brief.md` |
 | `bmad-prfaq` | Working Backwards — stress-test và rèn sắc concept sản phẩm của bạn | `prfaq-{project}.md` |
 ## Phase 2: Planning
 Xác định cần xây gì và xây cho ai.
 | Workflow | Mục đích | Tạo ra |
 | --------------------------- | ---------------------------------------- | ------------ |
 | `bmad-create-prd` | Xác định yêu cầu (FR/NFR) | `PRD.md` |
 | `bmad-create-ux-design` | Thiết kế trải nghiệm người dùng khi UX là yếu tố quan trọng | `ux-spec.md` |
 ## Phase 3: Solutioning
 Quyết định cách xây và chia nhỏ công việc thành stories.
 | Workflow | Mục đích | Tạo ra |
 | ----------------------------------------- | ------------------------------------------ | --------------------------- |
 | `bmad-create-architecture` | Làm rõ các quyết định kỹ thuật | `architecture.md` kèm ADR |
 | `bmad-create-epics-and-stories` | Phân rã yêu cầu thành các phần việc có thể triển khai | Các file epic chứa stories |
 | `bmad-check-implementation-readiness` | Cổng kiểm tra trước khi triển khai | Quyết định PASS/CONCERNS/FAIL |
 ## Phase 4: Implementation
 Xây dựng từng story một. Tự động hóa toàn bộ phase 4 sẽ sớm ra mắt.
 | Workflow | Mục đích | Tạo ra |
 | -------------------------- | ------------------------------------------------------------------------ | -------------------------------- |
 | `bmad-sprint-planning` | Khởi tạo theo dõi, thường chạy một lần mỗi dự án để sắp thứ tự chu trình dev | `sprint-status.yaml` |
 | `bmad-create-story` | Chuẩn bị story tiếp theo cho implementation | `story-[slug].md` |
 | `bmad-dev-story` | Triển khai story | Code chạy được + tests |
 | `bmad-code-review` | Kiểm tra chất lượng phần triển khai | Được duyệt hoặc yêu cầu thay đổi |
 | `bmad-correct-course` | Xử lý thay đổi lớn giữa sprint | Kế hoạch cập nhật hoặc định tuyến lại |
 | `bmad-sprint-status` | Theo dõi tiến độ sprint và trạng thái story | Cập nhật trạng thái sprint |
 | `bmad-retrospective` | Review sau khi hoàn tất epic | Bài học rút ra |
 ## Quick Flow (Nhánh Song Song)
 Bỏ qua phase 1-3 đối với những việc nhỏ, rõ và đã hiểu đầy đủ.
 | Workflow | Mục đích | Tạo ra |
 | ------------------ | --------------------------------------------------------------------------- | ---------------------- |
 | `bmad-quick-dev` | Luồng nhanh hợp nhất — làm rõ yêu cầu, lập kế hoạch, triển khai, review và trình bày | `spec-*.md` + mã nguồn |
 ## Quản Lý Context
 Mỗi tài liệu sẽ trở thành context cho phase tiếp theo. PRD cho architect biết những ràng buộc nào quan trọng. Architecture chỉ cho dev agent những pattern cần tuân theo. File story cung cấp context tập trung và đầy đủ cho việc triển khai. Nếu không có cấu trúc này, agent sẽ đưa ra quyết định thiếu nhất quán.
 ### Project Context
 :::tip[Khuyến nghị]
 Hãy tạo `project-context.md` để bảo đảm AI agent tuân theo quy tắc và sở thích của dự án. File này hoạt động như một bản hiến pháp cho dự án của bạn, nó dẫn dắt các quyết định triển khai xuyên suốt mọi workflow. File tùy chọn này có thể được tạo ở cuối bước Architecture Creation, hoặc cũng có thể được sinh trong dự án hiện hữu để ghi lại những điều quan trọng cần giữ đồng bộ với quy ước đang có.
 :::
 **Cách tạo:**
 - **Thủ công** — Tạo `_bmad-output/project-context.md` với stack công nghệ và các quy tắc triển khai của bạn
 - **Tự sinh** — Chạy `bmad-generate-project-context` để sinh tự động từ architecture hoặc codebase
 [**Tìm hiểu thêm về project-context.md**](../explanation/project-context.md)
--- a/docs/vi-vn/roadmap.mdx
+++ b/docs/vi-vn/roadmap.mdx
@ -0,0 +1,136 @@
 ---
 title: Lộ trình
 description: Điều gì sẽ đến tiếp theo với BMad - tính năng mới, cải tiến và đóng góp từ cộng đồng
 ---
 # Lộ Trình Công Khai Của BMad Method
 BMad Method, BMad Method Module (BMM) và BMad Builder (BMB) đang tiếp tục phát triển. Đây là những gì chúng tôi đang thực hiện và sắp ra mắt.
 <div class="roadmap-container">
  <h2 class="roadmap-section-title">Đang triển khai</h2>
  <div class="roadmap-future">
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🧩</span>
      <h4>Kiến Trúc Skills Phổ Quát</h4>
      <p>Một skill, dùng trên mọi nền tảng. Viết một lần, chạy ở khắp nơi.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🏗️</span>
      <h4>BMad Builder v1</h4>
      <p>Tạo AI agent và workflow sẵn sàng cho production với evals, teams và graceful degradation được tích hợp sẵn.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🧠</span>
      <h4>Hệ Thống Project Context</h4>
      <p>AI thực sự hiểu dự án của bạn. Ngữ cảnh nhận biết framework và phát triển cùng codebase của bạn.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">📦</span>
      <h4>Skills Tập Trung</h4>
      <p>Cài một lần, dùng ở mọi nơi. Chia sẻ skills giữa các dự án mà không làm rối file.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🔄</span>
      <h4>Skills Thích Ứng</h4>
      <p>Skills hiểu công cụ bạn đang dùng. Biến thể tối ưu cho Claude, Codex, Kimi, OpenCode và nhiều công cụ khác.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">📝</span>
      <h4>Blog BMad Team Pros</h4>
      <p>Các bài hướng dẫn, bài viết và góc nhìn từ đội ngũ. Sắp ra mắt.</p>
    </div>
  </div>
  <h2 class="roadmap-section-title">Mới bắt đầu</h2>
  <div class="roadmap-future">
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🏪</span>
      <h4>Chợ Skills</h4>
      <p>Khám phá, cài đặt và cập nhật skills do cộng đồng xây dựng. Chỉ cần một lệnh curl là có thêm siêu năng lực.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🎨</span>
      <h4>Tùy Biến Workflow</h4>
      <p>Biến nó thành của riêng bạn. Tích hợp Jira, Linear, output tùy chỉnh: workflow của bạn, luật của bạn.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🚀</span>
      <h4>Tối Ưu Hóa Phase 1-3</h4>
      <p>Lập kế hoạch cực nhanh với cơ chế thu thập context bằng sub-agent. YOLO mode kết hợp với hướng dẫn có kiểm soát.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🌐</span>
      <h4>Sẵn Sàng Cho Doanh Nghiệp</h4>
      <p>SSO, audit logs, team workspaces. Toàn bộ phần “không hào nhoáng” nhưng khiến doanh nghiệp yên tâm triển khai.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">💎</span>
      <h4>Bùng Nổ Module Cộng Đồng</h4>
      <p>Giải trí, bảo mật, trị liệu, roleplay và nhiều hơn nữa. Mở rộng nền tảng BMad Method.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">⚡</span>
      <h4>Tự Động Hóa Dev Loop</h4>
      <p>Chế độ autopilot tùy chọn cho phát triển phần mềm. Để AI xử lý flow trong khi vẫn giữ chất lượng ở mức cao.</p>
    </div>
  </div>
  <h2 class="roadmap-section-title">Cộng đồng và đội ngũ</h2>
  <div class="roadmap-future">
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🎙️</span>
      <h4>Podcast The BMad Method</h4>
      <p>Các cuộc trò chuyện về phát triển phần mềm AI-native. Ra mắt ngày 1 tháng 3 năm 2026.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🎓</span>
      <h4>Lớp Master Class The BMad Method</h4>
      <p>Đi từ người dùng thành chuyên gia. Đào sâu vào từng phase, từng workflow và từng bí quyết.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🏗️</span>
      <h4>Lớp Master Class BMad Builder</h4>
      <p>Tự xây agent của riêng bạn. Kỹ thuật nâng cao cho lúc bạn đã sẵn sàng tạo ra thứ mới, không chỉ sử dụng.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">⚡</span>
      <h4>BMad Prototype First</h4>
      <p>Từ ý tưởng đến prototype chạy được chỉ trong một phiên làm việc. Tạo ứng dụng mơ ước của bạn như một tác phẩm thủ công tinh chỉnh.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🌴</span>
      <h4>BMad BALM!</h4>
      <p>Quản trị cuộc sống cho người dùng AI-native. Tasks, habits, goals: AI copilot của bạn cho mọi thứ.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🖥️</span>
      <h4>Giao Diện Chính Thức</h4>
      <p>Một giao diện đẹp cho toàn bộ hệ sinh thái BMad. Sức mạnh của CLI, độ hoàn thiện của GUI.</p>
    </div>
    <div class="roadmap-future-card">
      <span class="roadmap-emoji">🔒</span>
      <h4>BMad in a Box</h4>
      <p>Tự host, air-gapped, chuẩn doanh nghiệp. Trợ lý AI của bạn, hạ tầng của bạn, quyền kiểm soát của bạn.</p>
    </div>
  </div>
  <div style="text-align: center; margin-top: 3rem; padding: 2rem; background: var(--color-bg-card); border-radius: 12px; border: 1px solid var(--color-border);">
    <h3 style="margin: 0 0 1rem;">Muốn đóng góp?</h3>
    <p style="color: var(--slate-color-400); margin: 0;">
      Đây mới chỉ là một phần của những gì đang được lên kế hoạch. Đội ngũ mã nguồn mở BMad luôn chào đón contributor!<br />
      <a href="https://github.com/bmad-code-org/BMAD-METHOD" style="color: var(--color-in-progress);">Tham gia cùng chúng tôi trên GitHub</a> để cùng định hình tương lai của phát triển phần mềm hướng AI.
    </p>
    <p style="color: var(--slate-color-400); margin: 1.5rem 0 0;">
      Nếu bạn thích những gì chúng tôi đang xây dựng, chúng tôi trân trọng cả <a href="https://buymeacoffee.com/bmad" style="color: var(--color-in-progress);">hỗ trợ</a> một lần lẫn hàng tháng.
    </p>
    <p style="color: var(--slate-color-400); margin: 1rem 0 0;">
      Với tài trợ doanh nghiệp, hợp tác, diễn thuyết, đào tạo hoặc liên hệ truyền thông:{" "}
      <a href="mailto:contact@bmadcode.com" style="color: var(--color-in-progress);">contact@bmadcode.com</a>
    </p>
  </div>
 </div>
--- a/docs/vi-vn/tutorials/getting-started.md
+++ b/docs/vi-vn/tutorials/getting-started.md
@ -0,0 +1,276 @@
 ---
 title: "Bắt đầu"
 description: Cài đặt BMad và xây dựng dự án đầu tiên của bạn
 ---
 Xây dựng phần mềm nhanh hơn bằng các workflow vận hành bởi AI, với những agent chuyên biệt hướng dẫn bạn qua các bước lập kế hoạch, kiến trúc và triển khai.
 ## Bạn Sẽ Học Được Gì
 - Cài đặt và khởi tạo BMad Method cho một dự án mới
 - Dùng **BMad-Help** — trợ lý thông minh biết bước tiếp theo bạn nên làm gì
 - Chọn nhánh lập kế hoạch phù hợp với quy mô dự án
 - Đi qua các phase từ yêu cầu đến code chạy được
 - Sử dụng agent và workflow hiệu quả
 :::note[Điều kiện tiên quyết]
 - **Node.js 20+** — Bắt buộc cho trình cài đặt
 - **Git** — Khuyến nghị để quản lý phiên bản
 - **IDE có AI** — Claude Code, Cursor hoặc công cụ tương tự
 - **Một ý tưởng dự án** — Chỉ cần đơn giản cũng đủ để học
 :::
 :::tip[Cách Dễ Nhất]
 **Cài đặt** → `npx bmad-method install`
 **Hỏi** → `bmad-help what should I do first?`
 **Xây dựng** → Để BMad-Help dẫn bạn qua từng workflow
 :::
 ## Làm Quen Với BMad-Help: Người Dẫn Đường Thông Minh Của Bạn
 **BMad-Help là cách nhanh nhất để bắt đầu với BMad.** Bạn không cần phải nhớ workflow hay phase nào cả, chỉ cần hỏi, và BMad-Help sẽ:
 - **Kiểm tra dự án của bạn** để xem những gì đã hoàn thành
 - **Hiển thị các lựa chọn** dựa trên những module bạn đã cài
 - **Đề xuất bước tiếp theo** — bao gồm cả tác vụ bắt buộc đầu tiên
 - **Trả lời câu hỏi** như “Tôi có ý tưởng cho một sản phẩm SaaS, tôi nên bắt đầu từ đâu?”
 ### Cách Dùng BMad-Help
 Chạy trong AI IDE của bạn bằng cách gọi skill:
 ```text
 bmad-help
 ```
 Hoặc ghép cùng câu hỏi để nhận hướng dẫn có ngữ cảnh:
 ```text
 bmad-help I have an idea for a SaaS product, I already know all the features I want. where do I get started?
 ```
 BMad-Help sẽ trả lời:
 - Điều gì được khuyến nghị trong tình huống của bạn
 - Tác vụ bắt buộc đầu tiên là gì
 - Phần còn lại của quy trình sẽ trông như thế nào
 ### Nó Cũng Điều Khiển Workflow
 BMad-Help không chỉ trả lời câu hỏi — **nó còn tự động chạy ở cuối mỗi workflow** để cho bạn biết chính xác bước tiếp theo cần làm là gì. Không phải đoán, không phải lục tài liệu, chỉ có chỉ dẫn rõ ràng về workflow bắt buộc tiếp theo.
 :::tip[Bắt Đầu Từ Đây]
 Sau khi cài BMad, hãy gọi skill `bmad-help` ngay. Nó sẽ nhận biết các module bạn đã cài và hướng bạn đến điểm bắt đầu phù hợp cho dự án.
 :::
 ## Hiểu Về BMad
 BMad giúp bạn xây dựng phần mềm thông qua các workflow có hướng dẫn với những AI agent chuyên biệt. Quy trình gồm bốn phase:
 | Phase | Tên | Điều xảy ra |
 | ----- | -------------- | --------------------------------------------------- |
 | 1 | Analysis | Brainstorming, nghiên cứu, product brief hoặc PRFAQ *(tùy chọn)* |
 | 2 | Planning | Tạo tài liệu yêu cầu (PRD hoặc spec) |
 | 3 | Solutioning | Thiết kế kiến trúc *(chỉ dành cho BMad Method/Enterprise)* |
 | 4 | Implementation | Xây dựng theo từng epic, từng story |
 **[Mở Workflow Map](../reference/workflow-map.md)** để khám phá các phase, workflow và cách quản lý context.
 Dựa trên độ phức tạp của dự án, BMad cung cấp ba nhánh lập kế hoạch:
 | Nhánh | Phù hợp nhất với | Tài liệu được tạo |
 | --------------- | ------------------------------------------------------ | -------------------------------------- |
 | **Quick Flow** | Sửa lỗi, tính năng đơn giản, phạm vi rõ ràng (1-15 story) | Chỉ spec |
 | **BMad Method** | Sản phẩm, nền tảng, tính năng phức tạp (10-50+ story) | PRD + Architecture + UX |
 | **Enterprise** | Yêu cầu tuân thủ, hệ thống đa tenant (30+ story) | PRD + Architecture + Security + DevOps |
 :::note
 Số lượng story chỉ là gợi ý, không phải định nghĩa cứng. Hãy chọn nhánh dựa trên nhu cầu lập kế hoạch, không phải phép đếm story.
 :::
 ## Cài Đặt
 Mở terminal trong thư mục dự án và chạy:
 ```bash
 npx bmad-method install
 ```
 Nếu bạn muốn dùng bản prerelease mới nhất thay vì kênh release mặc định, hãy dùng `npx bmad-method@next install`.
 Khi được hỏi chọn module, hãy chọn **BMad Method**.
 Trình cài đặt sẽ tạo hai thư mục:
 - `_bmad/` — agents, workflows, tasks và cấu hình
 - `_bmad-output/` — hiện tại để trống, nhưng đây là nơi các artifact của bạn sẽ được lưu
 :::tip[Bước Tiếp Theo Của Bạn]
 Mở AI IDE trong thư mục dự án rồi chạy:
 ```text
 bmad-help
 ```
 BMad-Help sẽ nhận biết bạn đã làm đến đâu và đề xuất chính xác bước tiếp theo. Bạn cũng có thể hỏi những câu như “Tôi có những lựa chọn nào?” hoặc “Tôi có ý tưởng SaaS, nên bắt đầu từ đâu?”
 :::
 :::note[Cách Nạp Agent Và Chạy Workflow]
 Mỗi workflow có một **skill** được gọi bằng tên trong IDE của bạn, ví dụ `bmad-create-prd`. Công cụ AI sẽ nhận diện tên `bmad-*` và chạy nó, bạn không cần nạp agent riêng. Bạn cũng có thể gọi trực tiếp skill của agent để trò chuyện tổng quát, ví dụ `bmad-agent-pm` cho PM agent.
 :::
 :::caution[Chat Mới]
 Luôn bắt đầu một chat mới cho mỗi workflow. Điều này tránh các vấn đề do giới hạn context gây ra.
 :::
 ## Bước 1: Tạo Kế Hoạch
 Đi qua các phase 1-3. **Dùng chat mới cho từng workflow.**
 :::tip[Project Context (Tùy chọn)]
 Trước khi bắt đầu, hãy cân nhắc tạo `project-context.md` để ghi lại các ưu tiên kỹ thuật và quy tắc triển khai. Nhờ vậy mọi AI agent sẽ tuân theo cùng một quy ước trong suốt dự án.
 Bạn có thể tạo thủ công tại `_bmad-output/project-context.md` hoặc sinh ra sau phần kiến trúc bằng `bmad-generate-project-context`. [Xem thêm](../explanation/project-context.md).
 :::
 ### Phase 1: Analysis (Tùy chọn)
 Tất cả workflow trong phase này đều là tùy chọn. [**Chưa chắc nên dùng cái nào?**](../explanation/analysis-phase.md)
 - **brainstorming** (`bmad-brainstorming`) — Gợi ý ý tưởng có hướng dẫn
 - **research** (`bmad-market-research` / `bmad-domain-research` / `bmad-technical-research`) — Nghiên cứu thị trường, miền nghiệp vụ và kỹ thuật
 - **product-brief** (`bmad-product-brief`) — Tài liệu nền tảng được khuyến nghị khi concept của bạn đã rõ
 - **prfaq** (`bmad-prfaq`) — Bài kiểm tra Working Backwards để stress-test và rèn sắc concept sản phẩm của bạn
 ### Phase 2: Planning (Bắt buộc)
 **Với nhánh BMad Method và Enterprise:**
 1. Gọi **PM agent** (`bmad-agent-pm`) trong một chat mới
 2. Chạy workflow `bmad-create-prd` (`bmad-create-prd`)
 3. Kết quả: `PRD.md`
 **Với nhánh Quick Flow:**
 - Chạy `bmad-quick-dev` — workflow này gộp cả planning và implementation trong một lần, nên bạn có thể chuyển thẳng sang triển khai
 :::note[Thiết kế UX (Tùy chọn)]
 Nếu dự án của bạn có giao diện người dùng, hãy gọi **UX-Designer agent** (`bmad-agent-ux-designer`) và chạy workflow thiết kế UX (`bmad-create-ux-design`) sau khi tạo PRD.
 :::
 ### Phase 3: Solutioning (BMad Method/Enterprise)
 **Tạo Architecture**
 1. Gọi **Architect agent** (`bmad-agent-architect`) trong một chat mới
 2. Chạy `bmad-create-architecture` (`bmad-create-architecture`)
 3. Kết quả: tài liệu kiến trúc chứa các quyết định kỹ thuật
 **Tạo Epics và Stories**
 :::tip[Cải tiến trong V6]
 Epics và stories giờ được tạo *sau* kiến trúc. Điều này giúp story có chất lượng tốt hơn vì các quyết định kiến trúc như database, API pattern và tech stack ảnh hưởng trực tiếp đến cách chia nhỏ công việc.
 :::
 1. Gọi **PM agent** (`bmad-agent-pm`) trong một chat mới
 2. Chạy `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
 3. Workflow sẽ dùng cả PRD lẫn Architecture để tạo story có đủ ngữ cảnh kỹ thuật
 **Kiểm tra mức sẵn sàng để triển khai** *(Rất nên dùng)*
 1. Gọi **Architect agent** (`bmad-agent-architect`) trong một chat mới
 2. Chạy `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
 3. Xác nhận tính nhất quán giữa toàn bộ tài liệu lập kế hoạch
 ## Bước 2: Xây Dựng Dự Án
 Sau khi lập kế hoạch xong, chuyển sang implementation. **Mỗi workflow nên chạy trong một chat mới.**
 ### Khởi Tạo Sprint Planning
 Gọi **Developer agent** (`bmad-agent-dev`) và chạy `bmad-sprint-planning` (`bmad-sprint-planning`). Workflow này sẽ tạo `sprint-status.yaml` để theo dõi toàn bộ epic và story.
 ### Chu Trình Xây Dựng
 Với mỗi story, lặp lại chu trình này trong chat mới:
 | Bước | Agent | Workflow | Lệnh | Mục đích |
 | ---- | ----- | -------------- | -------------------------- | ---------------------------------- |
 | 1 | DEV | `bmad-create-story` | `bmad-create-story` | Tạo file story từ epic |
 | 2 | DEV | `bmad-dev-story` | `bmad-dev-story` | Triển khai story |
 | 3 | DEV | `bmad-code-review` | `bmad-code-review` | Kiểm tra chất lượng *(khuyến nghị)* |
 Sau khi hoàn tất tất cả story trong một epic, hãy gọi **Developer agent** (`bmad-agent-dev`) và chạy `bmad-retrospective` (`bmad-retrospective`).
 ## Bạn Đã Hoàn Thành Những Gì
 Bạn đã nắm được nền tảng để xây dựng với BMad:
 - Đã cài BMad và cấu hình cho IDE của bạn
 - Đã khởi tạo dự án theo nhánh lập kế hoạch phù hợp
 - Đã tạo các tài liệu lập kế hoạch (PRD, Architecture, Epics và Stories)
 - Đã hiểu chu trình triển khai trong implementation
 Dự án của bạn bây giờ sẽ có dạng:
 ```text
 your-project/
 ├── _bmad/                                   # Cấu hình BMad
 ├── _bmad-output/
 │   ├── planning-artifacts/
 │   │   ├── PRD.md                           # Tài liệu yêu cầu của bạn
 │   │   ├── architecture.md                  # Các quyết định kỹ thuật
 │   │   └── epics/                           # Các file epic và story
 │   ├── implementation-artifacts/
 │   │   └── sprint-status.yaml               # Theo dõi sprint
 │   └── project-context.md                   # Quy tắc triển khai (tùy chọn)
 └── ...
 ```
 ## Tra Cứu Nhanh
 | Workflow | Lệnh | Agent | Mục đích |
 | ------------------------------------- | ------------------------------------------ | --------- | ----------------------------------------------- |
 | **`bmad-help`** ⭐ | `bmad-help` | Bất kỳ | **Người dẫn đường thông minh của bạn — hỏi gì cũng được!** |
 | `bmad-create-prd` | `bmad-create-prd` | PM | Tạo tài liệu yêu cầu sản phẩm |
 | `bmad-create-architecture` | `bmad-create-architecture` | Architect | Tạo tài liệu kiến trúc |
 | `bmad-generate-project-context` | `bmad-generate-project-context` | Analyst | Tạo file project context |
 | `bmad-create-epics-and-stories` | `bmad-create-epics-and-stories` | PM | Phân rã PRD thành epics |
 | `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | Kiểm tra độ nhất quán của kế hoạch |
 | `bmad-sprint-planning` | `bmad-sprint-planning` | DEV | Khởi tạo theo dõi sprint |
 | `bmad-create-story` | `bmad-create-story` | DEV | Tạo file story |
 | `bmad-dev-story` | `bmad-dev-story` | DEV | Triển khai một story |
 | `bmad-code-review` | `bmad-code-review` | DEV | Review phần code đã triển khai |
 ## Câu Hỏi Thường Gặp
 **Lúc nào cũng cần kiến trúc à?**
 Chỉ với nhánh BMad Method và Enterprise. Quick Flow bỏ qua bước kiến trúc và chuyển thẳng từ spec sang implementation.
 **Tôi có thể đổi kế hoạch về sau không?**
 Có. Workflow `bmad-correct-course` (`bmad-correct-course`) xử lý thay đổi phạm vi giữa chừng.
 **Nếu tôi muốn brainstorming trước thì sao?**
 Gọi Analyst agent (`bmad-agent-analyst`) và chạy `bmad-brainstorming` (`bmad-brainstorming`) trước khi bắt đầu PRD.
 **Tôi có cần tuân theo đúng thứ tự tuyệt đối không?**
 Không hẳn. Khi đã quen flow, bạn có thể chạy workflow trực tiếp bằng bảng Tra Cứu Nhanh ở trên.
 ## Nhận Hỗ Trợ
 :::tip[Điểm Dừng Đầu Tiên: BMad-Help]
 **Hãy gọi `bmad-help` bất cứ lúc nào** — đây là cách nhanh nhất để gỡ vướng. Bạn có thể hỏi:
 - "Tôi nên làm gì sau khi cài đặt?"
 - "Tôi đang kẹt ở workflow X"
 - "Tôi có những lựa chọn nào cho Y?"
 - "Cho tôi xem đến giờ đã làm được gì"
 BMad-Help sẽ kiểm tra dự án, phát hiện những gì bạn đã hoàn thành và chỉ cho bạn chính xác bước cần làm tiếp theo.
 :::
 - **Trong workflow** — Các agent sẽ hướng dẫn bạn bằng câu hỏi và giải thích
 - **Cộng đồng** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
 ## Những Điểm Cần Ghi Nhớ
 :::tip[Hãy Nhớ Các Điểm Này]
 - **Bắt đầu với `bmad-help`** — Trợ lý thông minh hiểu dự án và các lựa chọn của bạn
 - **Luôn dùng chat mới** — Mỗi workflow nên bắt đầu trong một chat riêng
 - **Nhánh rất quan trọng** — Quick Flow dùng `bmad-quick-dev`; Method/Enterprise cần PRD và kiến trúc
 - **BMad-Help chạy tự động** — Mỗi workflow đều kết thúc bằng hướng dẫn về bước tiếp theo
 :::
 Sẵn sàng bắt đầu chưa? Hãy cài BMad, gọi `bmad-help`, và để người dẫn đường thông minh của bạn đưa bạn đi tiếp.
--- a/docs/zh-cn/_STYLE_GUIDE.md
+++ b/docs/zh-cn/_STYLE_GUIDE.md
@ -353,7 +353,7 @@ Only for BMad Method and Enterprise tracks. Quick Flow skips to implementation.
 ### Can I change my plan later?
-Yes. The SM agent has a `bmad-correct-course` workflow for handling scope changes.
+Yes. The `bmad-correct-course` workflow handles scope changes mid-implementation.
 **Have a question not answered here?** [Open an issue](...) or ask in [Discord](...).
 ```
--- a/docs/zh-cn/how-to/non-interactive-installation.md
+++ b/docs/zh-cn/how-to/non-interactive-installation.md
@ -61,7 +61,7 @@ sidebar:
 **推荐：** `claude-code`、`cursor`
-运行一次 `npx bmad-method install` 交互式安装以查看完整的当前支持工具列表，或查看 [平台代码配置](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/cli/installers/lib/ide/platform-codes.yaml)。
+运行一次 `npx bmad-method install` 交互式安装以查看完整的当前支持工具列表，或查看 [平台代码配置](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/tools/installer/ide/platform-codes.yaml)。
 ## 安装模式
--- a/docs/zh-cn/how-to/upgrade-to-v6.md
+++ b/docs/zh-cn/how-to/upgrade-to-v6.md
@ -65,8 +65,8 @@ v6 新技能会安装到：
 1. 完成 v6 安装
 2. 将 `epics.md` 或 `epics/epic*.md` 放入 `_bmad-output/planning-artifacts/`
-3. 运行 Scrum Master 的 `bmad-sprint-planning` 工作流
+3. 运行 Developer 的 `bmad-sprint-planning` 工作流
-4. 告诉 SM 哪些史诗/故事已经完成
+4. 告知智能体哪些史诗/故事已经完成
 ## 你将获得
--- a/docs/zh-cn/reference/agents.md
+++ b/docs/zh-cn/reference/agents.md
@ -14,18 +14,15 @@ sidebar:
 | Analyst (Mary) | `bmad-analyst` | `BP`、`RS`、`CB`、`DP` | Brainstorm、Research、Create Brief、Document Project |
 | Product Manager (John) | `bmad-pm` | `CP`、`VP`、`EP`、`CE`、`IR`、`CC` | Create/Validate/Edit PRD、Create Epics and Stories、Implementation Readiness、Correct Course |
 | Architect (Winston) | `bmad-architect` | `CA`、`IR` | Create Architecture、Implementation Readiness |
-| Scrum Master (Bob) | `bmad-sm` | `SP`、`CS`、`ER`、`CC` | Sprint Planning、Create Story、Epic Retrospective、Correct Course |
+| Developer (Amelia) | `bmad-agent-dev` | `DS`、`QD`、`QA`、`CR`、`SP`、`CS`、`ER` | Dev Story、Quick Dev、QA Test Generation、Code Review、Sprint Planning、Create Story、Epic Retrospective |
 | Developer (Amelia) | `bmad-dev` | `DS`、`CR` | Dev Story、Code Review |
 | QA Engineer (Quinn) | `bmad-qa` | `QA` | Automate（为既有功能生成测试） |
 | Quick Flow Solo Dev (Barry) | `bmad-master` | `QD`、`CR` | Quick Dev、Code Review |
 | UX Designer (Sally) | `bmad-ux-designer` | `CU` | Create UX Design |
 | Technical Writer (Paige) | `bmad-tech-writer` | `DP`、`WD`、`US`、`MG`、`VD`、`EC` | Document Project、Write Document、Update Standards、Mermaid Generate、Validate Doc、Explain Concept |
 ## 使用说明
- `Skill ID` 是直接调用该智能体的名称（例如 `bmad-dev`）
+- `Skill ID` 是直接调用该智能体的名称（例如 `bmad-agent-dev`）
 - 触发器是进入智能体会话后可使用的菜单短码
- QA（Quinn）是 BMM 内置轻量测试角色；完整 TEA 能力位于独立模块
+- QA 测试生成由 `bmad-qa-generate-e2e-tests` workflow skill 处理，通过 Developer 智能体调用；完整 TEA 能力位于独立模块
 ## 触发器类型
--- a/docs/zh-cn/reference/commands.md
+++ b/docs/zh-cn/reference/commands.md
@ -48,12 +48,12 @@ sidebar:
 │   └── SKILL.md
 ├── bmad-create-prd/
 │   └── SKILL.md
-├── bmad-dev/
+├── bmad-agent-dev/
 │   └── SKILL.md
 └── ...
 ```
-skill 目录名就是调用名，例如 `bmad-dev/` 对应 skill `bmad-dev`。
+skill 目录名就是调用名，例如 `bmad-agent-dev/` 对应 skill `bmad-agent-dev`。
 ## 如何发现可用 skills
@ -73,10 +73,9 @@ skill 目录名就是调用名，例如 `bmad-dev/` 对应 skill `bmad-dev`。
 | 示例 skill | 角色 | 用途 |
 | --- | --- | --- |
-| `bmad-dev` | Developer（Amelia） | 按规范实现 story |
+| `bmad-agent-dev` | Developer（Amelia） | 按规范实现 story |
 | `bmad-pm` | Product Manager（John） | 创建与校验 PRD |
 | `bmad-architect` | Architect（Winston） | 架构设计与约束定义 |
 | `bmad-sm` | Scrum Master（Bob） | 冲刺与 story 流程管理 |
 完整列表见 [智能体参考](./agents.md)。
@ -105,7 +104,7 @@ skill 目录名就是调用名，例如 `bmad-dev/` 对应 skill `bmad-dev`。
 ## 命名规则
-所有技能统一以 `bmad-` 开头，后接语义化名称（如 `bmad-dev`、`bmad-create-prd`、`bmad-help`）。
+所有技能统一以 `bmad-` 开头，后接语义化名称（如 `bmad-agent-dev`、`bmad-create-prd`、`bmad-help`）。
 ## 故障排查
--- a/docs/zh-cn/reference/testing.md
+++ b/docs/zh-cn/reference/testing.md
@ -1,17 +1,17 @@
 ---
 title: "测试选项"
-description: 内置 QA（Quinn）与 TEA 模块对比：何时用哪个、各自边界是什么
+description: 内置 QA workflow 与 TEA 模块对比：何时用哪个、各自边界是什么
 sidebar:
  order: 5
 ---
 BMad 有两条测试路径：
- **Quinn（内置 QA）**：快速生成可运行测试
+- **内置 QA workflow**：快速生成可运行测试
 - **TEA（可选模块）**：企业级测试策略与治理能力
-## 该选 Quinn 还是 TEA？
+## 该选内置 QA 还是 TEA？
-| 维度 | Quinn（内置 QA） | TEA 模块 |
+| 维度 | 内置 QA | TEA 模块 |
 | --- | --- | --- |
 | 最适合 | 中小项目、快速补覆盖 | 大型项目、受监管或复杂业务 |
 | 安装成本 | 无需额外安装（BMM 内置） | 需通过安装器单独选择 |
@ -21,20 +21,20 @@ BMad 有两条测试路径：
 | workflow 数量 | 1（Automate） | 9（设计/自动化/审查/追溯等） |
 :::tip[默认建议]
-大多数项目先用 Quinn。只有当你需要质量门控、合规追溯或系统化测试治理时，再引入 TEA。
+大多数项目先用内置 QA workflow。只有当你需要质量门控、合规追溯或系统化测试治理时，再引入 TEA。
 :::
-## 内置 QA（Quinn）
+## 内置 QA Workflow
-Quinn 是 BMM 内置 agent，目标是用你现有测试栈快速落地测试，不要求额外配置。
+内置 QA workflow（`bmad-qa-generate-e2e-tests`）是 BMM 模块的一部分，通过 Developer 智能体调用。目标是用你现有测试栈快速落地测试，不要求额外配置。
 **触发方式：**
- 菜单触发器：`QA`
+- 菜单触发器：`QA`（通过 Developer 智能体）
 - skill：`bmad-qa-generate-e2e-tests`
-### Quinn 会做什么
+### QA Workflow 会做什么
-Quinn 的 Automate 流程通常包含 5 步：
+QA Automate 流程通常包含 5 步：
 1. 检测现有测试框架（如 Jest、Vitest、Playwright、Cypress）
 2. 确认待测功能（手动指定或自动发现）
 3. 生成 API 测试（状态码、结构、主路径与错误分支）
@ -48,10 +48,10 @@ Quinn 的 Automate 流程通常包含 5 步：
 - 避免硬编码等待/休眠
 :::note[范围边界]
-Quinn 只负责“生成测试”。如需实现质量评审与故事验收，请配合代码审查 workflow（`CR` / `bmad-code-review`）。
+QA workflow 只负责”生成测试”。如需实现质量评审与故事验收，请配合代码审查 workflow（`CR` / `bmad-code-review`）。
 :::
-### 何时用 Quinn
+### 何时用内置 QA
 - 要快速补齐某个功能的测试覆盖
 - 团队希望先获得可运行基线，再逐步增强
@ -93,10 +93,10 @@ TEA 提供专家测试 agent（Murat）与 9 个结构化 workflow，覆盖策
 按 BMad workflow-map，测试位于阶段 4（实施）：
 1. epic 内逐个 story：开发（`DS` / `bmad-dev-story`）+ 代码审查（`CR` / `bmad-code-review`）
-2. epic 完成后：用 Quinn 或 TEA 的 Automate 统一生成/补齐测试
+2. epic 完成后：用 `QA`（通过 Developer 智能体）或 TEA 的 Automate 统一生成/补齐测试
 3. 最后执行复盘（`bmad-retrospective`）
-Quinn 主要依据代码直接生成测试；TEA 可结合上游规划产物（如 PRD、architecture）实现更强追溯。
+内置 QA workflow 主要依据代码直接生成测试；TEA 可结合上游规划产物（如 PRD、architecture）实现更强追溯。
 ## 相关参考
--- a/docs/zh-cn/tutorials/getting-started.md
+++ b/docs/zh-cn/tutorials/getting-started.md
@ -180,7 +180,7 @@ BMad-Help 将检测你已完成的内容，并准确推荐下一步该做什么
 ### 初始化冲刺规划
-调用 **SM 智能体**（`bmad-agent-sm`）并运行 `bmad-sprint-planning`（`bmad-sprint-planning`）。这会创建 `sprint-status.yaml` 来跟踪所有史诗和故事。
+调用 **Developer 智能体**（`bmad-agent-dev`）并运行 `bmad-sprint-planning`（`bmad-sprint-planning`）。这会创建 `sprint-status.yaml` 来跟踪所有史诗和故事。
 ### 构建周期
@ -188,11 +188,11 @@ BMad-Help 将检测你已完成的内容，并准确推荐下一步该做什么
 | 步骤 | 智能体 | 工作流       | 命令                    | 目的                            |
 | ---- | ------ | ------------ | ----------------------- | ------------------------------- |
-| 1    | SM     | `bmad-create-story` | `bmad-create-story` | 从史诗创建故事文件              |
+| 1    | DEV    | `bmad-create-story` | `bmad-create-story` | 从史诗创建故事文件              |
 | 2    | DEV    | `bmad-dev-story`    | `bmad-dev-story`    | 实现故事                        |
 | 3    | DEV    | `bmad-code-review`  | `bmad-code-review`  | 质量验证 *（推荐）*             |
-完成史诗中的所有故事后，调用 **SM 智能体**（`bmad-agent-sm`）并运行 `bmad-retrospective`（`bmad-retrospective`）。
+完成史诗中的所有故事后，调用 **Developer 智能体**（`bmad-agent-dev`）并运行 `bmad-retrospective`（`bmad-retrospective`）。
 ## 你已完成的工作
@ -229,8 +229,8 @@ your-project/
 | `bmad-generate-project-context`     | `bmad-generate-project-context`        | Analyst  | 创建项目上下文文件                           |
 | `bmad-create-epics-and-stories`     | `bmad-create-epics-and-stories`        | PM       | 将 PRD 分解为史诗                            |
 | `bmad-check-implementation-readiness` | `bmad-check-implementation-readiness` | Architect | 验证规划一致性                              |
-| `bmad-sprint-planning`              | `bmad-sprint-planning`                 | SM       | 初始化冲刺跟踪                               |
+| `bmad-sprint-planning`              | `bmad-sprint-planning`                 | DEV      | 初始化冲刺跟踪                               |
-| `bmad-create-story`                 | `bmad-create-story`                    | SM       | 创建故事文件                                 |
+| `bmad-create-story`                 | `bmad-create-story`                    | DEV      | 创建故事文件                                 |
 | `bmad-dev-story`                    | `bmad-dev-story`                       | DEV      | 实现故事                                     |
 | `bmad-code-review`                  | `bmad-code-review`                     | DEV      | 审查已实现的代码                             |
@ -240,7 +240,7 @@ your-project/
 仅对于 BMad Method 和 Enterprise 路径。Quick Flow 从技术规范跳转到实现。
 **我可以稍后更改我的计划吗？**
-可以。SM 智能体提供 `bmad-correct-course` 工作流（`bmad-correct-course`）来处理范围变化。
+可以。`bmad-correct-course` 工作流用于处理实现过程中的范围变化。
 **如果我想先进行头脑风暴怎么办？**
 在开始 PRD 之前，调用 Analyst 智能体（`bmad-agent-analyst`）并运行 `bmad-brainstorming`（`bmad-brainstorming`）。
--- a/package.json
+++ b/package.json
@ -18,14 +18,14 @@
  },
  "license": "MIT",
  "author": "Brian (BMad) Madison",
-  "main": "tools/cli/bmad-cli.js",
+  "main": "tools/installer/bmad-cli.js",
  "bin": {
-    "bmad": "tools/bmad-npx-wrapper.js",
+    "bmad": "tools/installer/bmad-cli.js",
-    "bmad-method": "tools/bmad-npx-wrapper.js"
+    "bmad-method": "tools/installer/bmad-cli.js"
  },
  "scripts": {
-    "bmad:install": "node tools/cli/bmad-cli.js install",
+    "bmad:install": "node tools/installer/bmad-cli.js install",
-    "bmad:uninstall": "node tools/cli/bmad-cli.js uninstall",
+    "bmad:uninstall": "node tools/installer/bmad-cli.js uninstall",
    "docs:build": "node tools/build-docs.mjs",
    "docs:dev": "astro dev --root website",
    "docs:fix-links": "node tools/fix-doc-links.js",
@ -34,13 +34,13 @@
    "format:check": "prettier --check \"**/*.{js,cjs,mjs,json,yaml}\"",
    "format:fix": "prettier --write \"**/*.{js,cjs,mjs,json,yaml}\"",
    "format:fix:staged": "prettier --write",
-    "install:bmad": "node tools/cli/bmad-cli.js install",
+    "install:bmad": "node tools/installer/bmad-cli.js install",
    "lint": "eslint . --ext .js,.cjs,.mjs,.yaml --max-warnings=0",
    "lint:fix": "eslint . --ext .js,.cjs,.mjs,.yaml --fix",
    "lint:md": "markdownlint-cli2 \"**/*.md\"",
    "prepare": "command -v husky >/dev/null 2>&1 && husky || exit 0",
    "quality": "npm run format:check && npm run lint && npm run lint:md && npm run docs:build && npm run test:install && npm run validate:refs && npm run validate:skills",
-    "rebundle": "node tools/cli/bundlers/bundle-web.js rebundle",
+    "rebundle": "node tools/installer/bundlers/bundle-web.js rebundle",
    "test": "npm run test:refs && npm run test:install && npm run lint && npm run lint:md && npm run format:check",
    "test:install": "node test/test-installation-components.js",
    "test:refs": "node test/test-file-refs-csv.js",
@ -97,6 +97,7 @@
    "prettier": "^3.7.4",
    "prettier-plugin-packagejson": "^2.5.19",
    "sharp": "^0.33.5",
    "unist-util-visit": "^5.1.0",
    "yaml-eslint-parser": "^1.2.3",
    "yaml-lint": "^1.7.0"
  },
--- a/src/bmm-skills/1-analysis/bmad-agent-analyst/SKILL.md
+++ b/src/bmm-skills/1-analysis/bmad-agent-analyst/SKILL.md
@ -36,14 +36,17 @@ When you are in this persona and the user calls a skill, this persona must carry
 | DR | Industry domain deep dive, subject matter expertise and terminology | bmad-domain-research |
 | TR | Technical feasibility, architecture options and implementation approaches | bmad-technical-research |
 | CB | Create or update product briefs through guided or autonomous discovery | bmad-product-brief-preview |
 | WB | Working Backwards PRFAQ challenge — forge and stress-test product concepts | bmad-prfaq |
 | DP | Analyze an existing project to produce documentation for human and LLM consumption | bmad-document-project |
 ## On Activation
-1. **Load config via bmad-init skill** — Store all returned vars for use:
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
-   - Use `{user_name}` from config for greeting
+   - Use `{user_name}` for greeting
-   - Use `{communication_language}` from config for all communications
+   - Use `{communication_language}` for all communications
-   - Store any other config variables as `{var-name}` and use appropriately
+   - Use `{document_output_language}` for output documents
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
 2. **Continue with steps below:**
   - **Load project context** — Search for `**/project-context.md`. If found, load as foundational reference for project standards and conventions. If not found, continue without it.
--- a/src/bmm-skills/1-analysis/bmad-agent-tech-writer/SKILL.md
+++ b/src/bmm-skills/1-analysis/bmad-agent-tech-writer/SKILL.md
@ -39,10 +39,12 @@ When you are in this persona and the user calls a skill, this persona must carry
 ## On Activation
-1. **Load config via bmad-init skill** — Store all returned vars for use:
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
-   - Use `{user_name}` from config for greeting
+   - Use `{user_name}` for greeting
-   - Use `{communication_language}` from config for all communications
+   - Use `{communication_language}` for all communications
-   - Store any other config variables as `{var-name}` and use appropriately
+   - Use `{document_output_language}` for output documents
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
 2. **Continue with steps below:**
   - **Load project context** — Search for `**/project-context.md`. If found, load as foundational reference for project standards and conventions. If not found, continue without it.
--- a/src/bmm-skills/1-analysis/bmad-document-project/workflow.md
+++ b/src/bmm-skills/1-analysis/bmad-document-project/workflow.md
@ -9,16 +9,14 @@
 ## INITIALIZATION
-### Configuration Loading
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve::
   - Use `{user_name}` for greeting
   - Use `{communication_language}` for all communications
   - Use `{document_output_language}` for output documents
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
-Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+2. **Greet user** as `{user_name}`, speaking in `{communication_language}`.
 - `project_knowledge`
 - `user_name`
 - `communication_language`
 - `document_output_language`
 - `user_skill_level`
 - `date` as system-generated current datetime
 ---
--- a/src/bmm-skills/1-analysis/bmad-prfaq/SKILL.md
+++ b/src/bmm-skills/1-analysis/bmad-prfaq/SKILL.md
@ -0,0 +1,96 @@
 ---
 name: bmad-prfaq
 description: Working Backwards PRFAQ challenge to forge product concepts. Use when the user requests to 'create a PRFAQ', 'work backwards', or 'run the PRFAQ challenge'.
 ---
 # Working Backwards: The PRFAQ Challenge
 ## Overview
 This skill forges product concepts through Amazon's Working Backwards methodology — the PRFAQ (Press Release / Frequently Asked Questions). Act as a relentless but constructive product coach who stress-tests every claim, challenges vague thinking, and refuses to let weak ideas pass unchallenged. The user walks in with an idea. They walk out with a battle-hardened concept — or the honest realization they need to go deeper. Both are wins.
 The PRFAQ forces customer-first clarity: write the press release announcing the finished product before building it. If you can't write a compelling press release, the product isn't ready. The customer FAQ validates the value proposition from the outside in. The internal FAQ addresses feasibility, risks, and hard trade-offs.
 **This is hardcore mode.** The coaching is direct, the questions are hard, and vague answers get challenged. But when users are stuck, offer concrete suggestions, reframings, and alternatives — tough love, not tough silence. The goal is to strengthen the concept, not to gatekeep it.
 **Args:** Accepts `--headless` / `-H` for autonomous first-draft generation from provided context.
 **Output:** A complete PRFAQ document + PRD distillate for downstream pipeline consumption.
 **Research-grounded.** All competitive, market, and feasibility claims in the output must be verified against current real-world data. Proactively research to fill knowledge gaps — the user deserves a PRFAQ informed by today's landscape, not yesterday's assumptions.
 ## On Activation
 1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve::
   - Use `{user_name}` for greeting
   - Use `{communication_language}` for all communications
   - Use `{document_output_language}` for output documents
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
 2. **Greet user** as `{user_name}`, speaking in `{communication_language}`. Be warm but efficient — dream builder energy.
 3. **Resume detection:** Check if `{planning_artifacts}/prfaq-{project_name}.md` already exists. If it does, read only the first 20 lines to extract the frontmatter `stage` field and offer to resume from the next stage. Do not read the full document. If the user confirms, route directly to that stage's reference file.
 4. **Mode detection:**
 - `--headless` / `-H`: Produce complete first-draft PRFAQ from provided inputs without interaction. Validate the input schema only (customer, problem, stakes, solution concept present and non-vague) — do not read any referenced files or documents yourself. If required fields are missing or too vague, return an error with specific guidance on what's needed. Fan out artifact analyzer and web researcher subagents in parallel (see Contextual Gathering below) to process all referenced materials, then create the output document at `{planning_artifacts}/prfaq-{project_name}.md` using `./assets/prfaq-template.md` and route to `./references/press-release.md`.
 - Default: Full interactive coaching — the gauntlet.
 **Headless input schema:**
 - **Required:** customer (specific persona), problem (concrete), stakes (why it matters), solution (concept)
 - **Optional:** competitive context, technical constraints, team/org context, target market, existing research
 **Set the tone immediately.** This isn't a warm, exploratory greeting. Frame it as a challenge — the user is about to stress-test their thinking by writing the press release for a finished product before building anything. Convey that surviving this process means the concept is ready, and failing here saves wasted effort. Be direct and energizing.
 Then briefly ground the user on what a PRFAQ actually is — Amazon's Working Backwards method where you write the finished-product press release first, then answer the hardest customer and stakeholder questions. The point is forcing clarity before committing resources.
 Then proceed to Stage 1 below.
 ## Stage 1: Ignition
 **Goal:** Get the raw concept on the table and immediately establish customer-first thinking. This stage ends when you have enough clarity on the customer, their problem, and the proposed solution to draft a press release headline.
 **Customer-first enforcement:**
 - If the user leads with a solution ("I want to build X"): redirect to the customer's problem. Don't let them skip the pain.
 - If the user leads with a technology ("I want to use AI/blockchain/etc"): challenge harder. Technology is a "how", not a "why" — push them to articulate the human problem. Strip away the buzzword and ask whether anyone still cares.
 - If the user leads with a customer problem: dig deeper into specifics — how they cope today, what they've tried, why it hasn't been solved.
 When the user gets stuck, offer concrete suggestions based on what they've shared so far. Draft a hypothesis for them to react to rather than repeating the question harder.
 **Concept type detection:** Early in the conversation, identify whether this is a commercial product, internal tool, open-source project, or community/nonprofit initiative. Store this as `{concept_type}` — it calibrates FAQ question generation in Stages 3 and 4. Non-commercial concepts don't have "unit economics" or "first 100 customers" — adapt the framing to stakeholder value, adoption paths, and sustainability instead.
 **Essentials to capture before progressing:**
 - Who is the customer/user? (specific persona, not "everyone")
 - What is their problem? (concrete and felt, not abstract)
 - Why does this matter to them? (stakes and consequences)
 - What's the initial concept for a solution? (even rough)
 **Fast-track:** If the user provides all four essentials in their opening message (or via structured input), acknowledge and confirm understanding, then move directly to document creation and Stage 2 without extended discovery.
 **Graceful redirect:** If after 2-3 exchanges the user can't articulate a customer or problem, don't force it — suggest the idea may need more exploration first and recommend they invoke the `bmad-brainstorming` skill to develop it further.
 **Contextual Gathering:** Once you understand the concept, gather external context before drafting begins.
 1. **Ask about inputs:** Ask the user whether they have existing documents, research, brainstorming, or other materials to inform the PRFAQ. Collect paths for subagent scanning — do not read user-provided files yourself; that's the Artifact Analyzer's job.
 2. **Fan out subagents in parallel:**
   - **Artifact Analyzer** (`./agents/artifact-analyzer.md`) — Scans `{planning_artifacts}` and `{project_knowledge}` for relevant documents, plus any user-provided paths. Receives the product intent summary so it knows what's relevant.
   - **Web Researcher** (`./agents/web-researcher.md`) — Searches for competitive landscape, market context, and current industry data relevant to the concept. Receives the product intent summary.
 3. **Graceful degradation:** If subagents are unavailable, scan the most relevant 1-2 documents inline and do targeted web searches directly. Never block the workflow.
 4. **Merge findings** with what the user shared. Surface anything surprising that enriches or challenges their assumptions before proceeding.
 **Create the output document** at `{planning_artifacts}/prfaq-{project_name}.md` using `./assets/prfaq-template.md`. Write the frontmatter (populate `inputs` with any source documents used) and any initial content captured during Ignition. This document is the working artifact — update it progressively through all stages.
 **Coaching Notes Capture:** Before moving on, append a `<!-- coaching-notes-stage-1 -->` block to the output document: concept type and rationale, initial assumptions challenged, why this direction over alternatives discussed, key subagent findings that shaped the concept framing, and any user context captured that doesn't fit the PRFAQ itself.
 **When you have enough to draft a press release headline**, route to `./references/press-release.md`.
 ## Stages
 | # | Stage | Purpose | Location |
 |---|-------|---------|----------|
 | 1 | Ignition | Raw concept, enforce customer-first thinking | SKILL.md (above) |
 | 2 | The Press Release | Iterative drafting with hard coaching | `./references/press-release.md` |
 | 3 | Customer FAQ | Devil's advocate customer questions | `./references/customer-faq.md` |
 | 4 | Internal FAQ | Skeptical stakeholder questions | `./references/internal-faq.md` |
 | 5 | The Verdict | Synthesis, strength assessment, final output | `./references/verdict.md` |
--- a/src/bmm-skills/1-analysis/bmad-prfaq/agents/artifact-analyzer.md
+++ b/src/bmm-skills/1-analysis/bmad-prfaq/agents/artifact-analyzer.md
@ -0,0 +1,60 @@
 # Artifact Analyzer
 You are a research analyst. Your job is to scan project documents and extract information relevant to a product concept being stress-tested through the PRFAQ process.
 ## Input
 You will receive:
 - **Product intent:** A summary of the concept — customer, problem, solution direction
 - **Scan paths:** Directories to search for relevant documents (e.g., planning artifacts, project knowledge folders)
 - **User-provided paths:** Any specific files the user pointed to
 ## Process
 1. **Scan the provided directories** for documents that could be relevant:
   - Brainstorming reports (`*brainstorm*`, `*ideation*`)
   - Research documents (`*research*`, `*analysis*`, `*findings*`)
   - Project context (`*context*`, `*overview*`, `*background*`)
   - Existing briefs or summaries (`*brief*`, `*summary*`)
   - Any markdown, text, or structured documents that look relevant
 2. **For sharded documents** (a folder with `index.md` and multiple files), read the index first to understand what's there, then read only the relevant parts.
 3. **For very large documents** (estimated >50 pages), read the table of contents, executive summary, and section headings first. Read only sections directly relevant to the stated product intent. Note which sections were skimmed vs read fully.
 4. **Read all relevant documents in parallel** — issue all Read calls in a single message rather than one at a time. Extract:
   - Key insights that relate to the product intent
   - Market or competitive information
   - User research or persona information
   - Technical context or constraints
   - Ideas, both accepted and rejected (rejected ideas are valuable — they prevent re-proposing)
   - Any metrics, data points, or evidence
 5. **Ignore documents that aren't relevant** to the stated product intent. Don't waste tokens on unrelated content.
 ## Output
 Return ONLY the following JSON object. No preamble, no commentary. Keep total response under 1,500 tokens. Maximum 5 bullets per section — prioritize the most impactful findings.
 ```json
 {
  "documents_found": [
    {"path": "file path", "relevance": "one-line summary"}
  ],
  "key_insights": [
    "bullet — grouped by theme, each self-contained"
  ],
  "user_market_context": [
    "bullet — users, market, competition found in docs"
  ],
  "technical_context": [
    "bullet — platforms, constraints, integrations"
  ],
  "ideas_and_decisions": [
    {"idea": "description", "status": "accepted|rejected|open", "rationale": "brief why"}
  ],
  "raw_detail_worth_preserving": [
    "bullet — specific details, data points, quotes for the distillate"
  ]
 }
 ```
--- a/src/bmm-skills/1-analysis/bmad-prfaq/agents/web-researcher.md
+++ b/src/bmm-skills/1-analysis/bmad-prfaq/agents/web-researcher.md
@ -0,0 +1,49 @@
 # Web Researcher
 You are a market research analyst. Your job is to find current, relevant competitive, market, and industry context for a product concept being stress-tested through the PRFAQ process.
 ## Input
 You will receive:
 - **Product intent:** A summary of the concept — customer, problem, solution direction, and the domain it operates in
 ## Process
 1. **Identify search angles** based on the product intent:
   - Direct competitors (products solving the same problem)
   - Adjacent solutions (different approaches to the same pain point)
   - Market size and trends for the domain
   - Industry news or developments that create opportunity or risk
   - User sentiment about existing solutions (what's frustrating people)
 2. **Execute 3-5 targeted web searches** — quality over quantity. Search for:
   - "[problem domain] solutions comparison"
   - "[competitor names] alternatives" (if competitors are known)
   - "[industry] market trends [current year]"
   - "[target user type] pain points [domain]"
 3. **Synthesize findings** — don't just list links. Extract the signal.
 ## Output
 Return ONLY the following JSON object. No preamble, no commentary. Keep total response under 1,000 tokens. Maximum 5 bullets per section.
 ```json
 {
  "competitive_landscape": [
    {"name": "competitor", "approach": "one-line description", "gaps": "where they fall short"}
  ],
  "market_context": [
    "bullet — market size, growth trends, relevant data points"
  ],
  "user_sentiment": [
    "bullet — what users say about existing solutions"
  ],
  "timing_and_opportunity": [
    "bullet — why now, enabling shifts"
  ],
  "risks_and_considerations": [
    "bullet — market risks, competitive threats, regulatory concerns"
  ]
 }
 ```
--- a/src/bmm-skills/1-analysis/bmad-prfaq/assets/prfaq-template.md
+++ b/src/bmm-skills/1-analysis/bmad-prfaq/assets/prfaq-template.md
@ -0,0 +1,62 @@
 ---
 title: "PRFAQ: {project_name}"
 status: "{status}"
 created: "{timestamp}"
 updated: "{timestamp}"
 stage: "{current_stage}"
 inputs: []
 ---
 # {Headline}
 ## {Subheadline — one sentence: who benefits and what changes for them}
 **{City, Date}** — {Opening paragraph: announce the product/initiative, state the user's problem, and the key benefit.}
 {Problem paragraph: the user's pain today. Specific, concrete, felt. No mention of the solution yet.}
 {Solution paragraph: what changes for the user. Benefits, not features. Outcomes, not implementation.}
 > "{Leader/founder quote — the vision beyond the feature list.}"
 > — {Name, Title/Role}
 ### How It Works
 {The user experience, step by step. Written from THEIR perspective. How they discover it, start using it, and get value from it.}
 > "{User quote — what a real person would say after using this. Must sound human, not like marketing copy.}"
 > — {Name, Role}
 ### Getting Started
 {Clear, concrete path to first value. How to access, try, adopt, or contribute.}
 ---
 ## Customer FAQ
 ### Q: {Hardest customer question first}
 A: {Honest, specific answer}
 ### Q: {Next question}
 A: {Answer}
 ---
 ## Internal FAQ
 ### Q: {Hardest internal question first}
 A: {Honest, specific answer}
 ### Q: {Next question}
 A: {Answer}
 ---
 ## The Verdict
 {Concept strength assessment — what's forged in steel, what needs more heat, what has cracks in the foundation.}
--- a/src/bmm-skills/1-analysis/bmad-prfaq/bmad-manifest.json
+++ b/src/bmm-skills/1-analysis/bmad-prfaq/bmad-manifest.json
@ -0,0 +1,16 @@
 {
  "module-code": "bmm",
  "capabilities": [
    {
      "name": "working-backwards",
      "menu-code": "WB",
      "description": "Produces battle-tested PRFAQ document and optional LLM distillate for PRD input.",
      "supports-headless": true,
      "phase-name": "1-analysis",
      "after": ["brainstorming", "perform-research"],
      "before": ["create-prd"],
      "is-required": false,
      "output-location": "{planning_artifacts}"
    }
  ]
 }
--- a/src/bmm-skills/1-analysis/bmad-prfaq/references/customer-faq.md
+++ b/src/bmm-skills/1-analysis/bmad-prfaq/references/customer-faq.md
@ -0,0 +1,55 @@
 **Language:** Use `{communication_language}` for all output.
 **Output Language:** Use `{document_output_language}` for documents.
 **Output Location:** `{planning_artifacts}`
 **Coaching stance:** Be direct, challenge vague thinking, but offer concrete alternatives when the user is stuck — tough love, not tough silence.
 **Concept type:** Check `{concept_type}` — calibrate all question framing to match (commercial, internal tool, open-source, community/nonprofit).
 # Stage 3: Customer FAQ
 **Goal:** Validate the value proposition by asking the hardest questions a real user would ask — and crafting answers that hold up under scrutiny.
 ## The Devil's Advocate
 You are now the customer. Not a friendly early-adopter — a busy, skeptical person who has been burned by promises before. You've read the press release. Now you have questions.
 **Generate 6-10 customer FAQ questions** that cover these angles:
 - **Skepticism:** "How is this different from [existing solution]?" / "Why should I switch from what I use today?"
 - **Trust:** "What happens to my data?" / "What if this shuts down?" / "Who's behind this?"
 - **Practical concerns:** "How much does it cost?" / "How long does it take to get started?" / "Does it work with [thing I already use]?"
 - **Edge cases:** "What if I need to [uncommon but real scenario]?" / "Does it work for [adjacent use case]?"
 - **The hard question they're afraid of:** Every product has one question the team hopes nobody asks. Find it and ask it.
 **Don't generate softball questions.** "How do I sign up?" is not a FAQ — it's a CTA. Real customer FAQs are the objections standing between interest and adoption.
 **Calibrate to concept type.** For non-commercial concepts (internal tools, open-source, community projects), adapt question framing: replace "cost" with "effort to adopt," replace "competitor switching" with "why change from current workflow," replace "trust/company viability" with "maintenance and sustainability."
 ## Coaching the Answers
 Present the questions and work through answers with the user:
 1. **Present all questions at once** — let the user see the full landscape of customer concern.
 2. **Work through answers together.** The user drafts (or you draft and they react). For each answer:
   - Is it honest? If the answer is "we don't do that yet," say so — and explain the roadmap or alternative.
   - Is it specific? "We have enterprise-grade security" is not an answer. What certifications? What encryption? What SLA?
   - Would a customer believe it? Marketing language in FAQ answers destroys credibility.
 3. **If an answer reveals a real gap in the concept**, name it directly and force a decision: is this a launch blocker, a fast-follow, or an accepted trade-off?
 4. **The user can add their own questions too.** Often they know the scary questions better than anyone.
 ## Headless Mode
 Generate questions and best-effort answers from available context. Flag answers with low confidence so a human can review.
 ## Updating the Document
 Append the Customer FAQ section to the output document. Update frontmatter: `status: "customer-faq"`, `stage: 3`, `updated` timestamp.
 ## Coaching Notes Capture
 Before moving on, append a `<!-- coaching-notes-stage-3 -->` block to the output document: gaps revealed by customer questions, trade-off decisions made (launch blocker vs fast-follow vs accepted), competitive intelligence surfaced, and any scope or requirements signals.
 ## Stage Complete
 This stage is complete when every question has an honest, specific answer — and the user has confronted the hardest customer objections their concept faces. No softballs survived.
 Route to `./internal-faq.md`.
--- a/src/bmm-skills/1-analysis/bmad-prfaq/references/internal-faq.md
+++ b/src/bmm-skills/1-analysis/bmad-prfaq/references/internal-faq.md
@ -0,0 +1,51 @@
 **Language:** Use `{communication_language}` for all output.
 **Output Language:** Use `{document_output_language}` for documents.
 **Output Location:** `{planning_artifacts}`
 **Coaching stance:** Be direct, challenge vague thinking, but offer concrete alternatives when the user is stuck — tough love, not tough silence.
 **Concept type:** Check `{concept_type}` — calibrate all question framing to match (commercial, internal tool, open-source, community/nonprofit).
 # Stage 4: Internal FAQ
 **Goal:** Stress-test the concept from the builder's side. The customer FAQ asked "should I use this?" The internal FAQ asks "can we actually pull this off — and should we?"
 ## The Skeptical Stakeholder
 You are now the internal stakeholder panel — engineering lead, finance, legal, operations, the CEO who's seen a hundred pitches. The press release was inspiring. Now prove it's real.
 **Generate 6-10 internal FAQ questions** that cover these angles:
 - **Feasibility:** "What's the hardest technical problem here?" / "What do we not know how to build yet?" / "What are the key dependencies and risks?"
 - **Business viability:** "What does the unit economics look like?" / "How do we acquire the first 100 customers?" / "What's the competitive moat — and how durable is it?"
 - **Resource reality:** "What does the team need to look like?" / "What's the realistic timeline to a usable product?" / "What do we have to say no to in order to do this?"
 - **Risk:** "What kills this?" / "What's the worst-case scenario if we ship and it doesn't work?" / "What regulatory or legal exposure exists?"
 - **Strategic fit:** "Why us? Why now?" / "What does this cannibalize?" / "If this succeeds, what does the company look like in 3 years?"
 - **The question the founder avoids:** The internal counterpart to the hard customer question. The thing that keeps them up at night but hasn't been said out loud.
 **Calibrate questions to context.** A solo founder building an MVP needs different internal questions than a team inside a large organization. Don't ask about "board alignment" for a weekend project. Don't ask about "weekend viability" for an enterprise product. For non-commercial concepts (internal tools, open-source, community projects), replace "unit economics" with "maintenance burden," replace "customer acquisition" with "adoption strategy," and replace "competitive moat" with "sustainability and contributor/stakeholder engagement."
 ## Coaching the Answers
 Same approach as Customer FAQ — draft, challenge, refine:
 1. **Present all questions at once.**
 2. **Work through answers.** Demand specificity. "We'll figure it out" is not an answer. Neither is "we'll hire for that." What's the actual plan?
 3. **Honest unknowns are fine — unexamined unknowns are not.** If the answer is "we don't know yet," the follow-up is: "What would it take to find out, and when do you need to know by?"
 4. **Watch for hand-waving on resources and timeline.** These are the most commonly over-optimistic answers. Push for concrete scoping.
 ## Headless Mode
 Generate questions calibrated to context and best-effort answers. Flag high-risk areas and unknowns prominently.
 ## Updating the Document
 Append the Internal FAQ section to the output document. Update frontmatter: `status: "internal-faq"`, `stage: 4`, `updated` timestamp.
 ## Coaching Notes Capture
 Before moving on, append a `<!-- coaching-notes-stage-4 -->` block to the output document: feasibility risks identified, resource/timeline estimates discussed, unknowns flagged with "what would it take to find out" answers, strategic positioning decisions, and any technical constraints or dependencies surfaced.
 ## Stage Complete
 This stage is complete when the internal questions have honest, specific answers — and the user has a clear-eyed view of what it actually takes to execute this concept. Optimism is fine. Delusion is not.
 Route to `./verdict.md`.
--- a/src/bmm-skills/1-analysis/bmad-prfaq/references/press-release.md
+++ b/src/bmm-skills/1-analysis/bmad-prfaq/references/press-release.md
@ -0,0 +1,60 @@
 **Language:** Use `{communication_language}` for all output.
 **Output Language:** Use `{document_output_language}` for documents.
 **Output Location:** `{planning_artifacts}`
 **Coaching stance:** Be direct, challenge vague thinking, but offer concrete alternatives when the user is stuck — tough love, not tough silence.
 # Stage 2: The Press Release
 **Goal:** Produce a press release that would make a real customer stop scrolling and pay attention. Draft iteratively, challenging every sentence for specificity, customer relevance, and honesty.
 **Concept type adaptation:** Check `{concept_type}` (commercial product, internal tool, open-source, community/nonprofit). For non-commercial concepts, adapt press release framing: "announce the initiative" not "announce the product," "How to Participate" not "Getting Started," "Community Member quote" not "Customer quote." The structure stays — the language shifts to match the audience.
 ## The Forge
 The press release is the heart of Working Backwards. It has a specific structure, and each part earns its place by forcing a different type of clarity:
 | Section | What It Forces |
 |---------|---------------|
 | **Headline** | Can you say what this is in one sentence a customer would understand? |
 | **Subheadline** | Who benefits and what changes for them? |
 | **Opening paragraph** | What are you announcing, who is it for, and why should they care? |
 | **Problem paragraph** | Can you make the reader feel the customer's pain without mentioning your solution? |
 | **Solution paragraph** | What changes for the customer? (Not: what did you build.) |
 | **Leader quote** | What's the vision beyond the feature list? |
 | **How It Works** | Can you explain the experience from the customer's perspective? |
 | **Customer quote** | Would a real person say this? Does it sound human? |
 | **Getting Started** | Is the path to value clear and concrete? |
 ## Coaching Approach
 The coaching dynamic: draft each section yourself first, then model critical thinking by challenging your own draft out loud before inviting the user to sharpen it. Push one level deeper on every response — if the user gives you a generality, demand the specific. The cycle is: draft → self-challenge → invite → deepen.
 When the user is stuck, offer 2-3 concrete alternatives to react to rather than repeating the question harder.
 ## Quality Bars
 These are the standards to hold the press release to. Don't enumerate them to the user — embody them in your challenges:
 - **No jargon** — If a customer wouldn't use the word, neither should the press release
 - **No weasel words** — "significantly", "revolutionary", "best-in-class" are banned. Replace with specifics.
 - **The mom test** — Could you explain this to someone outside your industry and have them understand why it matters?
 - **The "so what?" test** — Every sentence should survive "so what?" If it can't, cut or sharpen it.
 - **Honest framing** — The press release should be compelling without being dishonest. If you're overselling, the customer FAQ will expose it.
 ## Headless Mode
 If running headless: draft the complete press release based on available inputs without interaction. Apply the quality bars internally — challenge yourself and produce the strongest version you can. Write directly to the output document.
 ## Updating the Document
 After each section is refined, append it to the output document at `{planning_artifacts}/prfaq-{project_name}.md`. Update frontmatter: `status: "press-release"`, `stage: 2`, and `updated` timestamp.
 ## Coaching Notes Capture
 Before moving on, append a brief `<!-- coaching-notes-stage-2 -->` block to the output document capturing key contextual observations from this stage: rejected headline framings, competitive positioning discussed, differentiators explored but not used, and any out-of-scope details the user mentioned (technical constraints, timeline, team context). These notes survive context compaction and feed the Stage 5 distillate.
 ## Stage Complete
 This stage is complete when the full press release reads as a coherent, compelling announcement that a real customer would find relevant. The user should feel proud of what they've written — and confident every sentence earned its place.
 Route to `./customer-faq.md`.
--- a/src/bmm-skills/1-analysis/bmad-prfaq/references/verdict.md
+++ b/src/bmm-skills/1-analysis/bmad-prfaq/references/verdict.md
@ -0,0 +1,79 @@
 **Language:** Use `{communication_language}` for all output.
 **Output Language:** Use `{document_output_language}` for documents.
 **Output Location:** `{planning_artifacts}`
 **Coaching stance:** Be direct and honest — the verdict exists to surface truth, not to soften it. But frame every finding constructively.
 # Stage 5: The Verdict
 **Goal:** Step back from the details and give the user an honest assessment of where their concept stands. Finalize the PRFAQ document and produce the downstream distillate.
 ## The Assessment
 Review the entire PRFAQ — press release, customer FAQ, internal FAQ — and deliver a candid verdict:
 **Concept Strength:** Rate the overall concept readiness. Not a score — a narrative assessment. Where is the thinking sharp and where is it still soft? What survived the gauntlet and what barely held together?
 **Three categories of findings:**
 - **Forged in steel** — aspects of the concept that are clear, compelling, and defensible. The press release sections that would actually make a customer stop. The FAQ answers that are honest and convincing.
 - **Needs more heat** — areas that are promising but underdeveloped. The user has a direction but hasn't gone deep enough. These need more work before they're ready for a PRD.
 - **Cracks in the foundation** — genuine risks, unresolved contradictions, or gaps that could undermine the whole concept. Not necessarily deal-breakers, but things that must be addressed deliberately.
 **Present the verdict directly.** Don't soften it. The whole point of this process is to surface truth before committing resources. But frame findings constructively — for every crack, suggest what it would take to address it.
 ## Finalize the Document
 1. **Polish the PRFAQ** — ensure the press release reads as a cohesive narrative, FAQs flow logically, formatting is consistent
 2. **Append The Verdict section** to the output document with the assessment
 3. Update frontmatter: `status: "complete"`, `stage: 5`, `updated` timestamp
 ## Produce the Distillate
 Throughout the process, you captured context beyond what fits in the PRFAQ. Source material for the distillate includes the `<!-- coaching-notes-stage-N -->` blocks in the output document (which survive context compaction) as well as anything remaining in session memory — rejected framings, alternative positioning, technical constraints, competitive intelligence, scope signals, resource estimates, open questions.
 **Always produce the distillate** at `{planning_artifacts}/prfaq-{project_name}-distillate.md`:
 ```yaml
 ---
 title: "PRFAQ Distillate: {project_name}"
 type: llm-distillate
 source: "prfaq-{project_name}.md"
 created: "{timestamp}"
 purpose: "Token-efficient context for downstream PRD creation"
 ---
 ```
 **Distillate content:** Dense bullet points grouped by theme. Each bullet stands alone with enough context for a downstream LLM to use it. Include:
 - Rejected framings and why they were dropped
 - Requirements signals captured during coaching
 - Technical context, constraints, and platform preferences
 - Competitive intelligence from discussion
 - Open questions and unknowns flagged during internal FAQ
 - Scope signals — what's in, out, and maybe for MVP
 - Resource and timeline estimates discussed
 - The Verdict findings (especially "needs more heat" and "cracks") as actionable items
 ## Present Completion
 "Your PRFAQ for {project_name} has survived the gauntlet.
 **PRFAQ:** `{planning_artifacts}/prfaq-{project_name}.md`
 **Detail Pack:** `{planning_artifacts}/prfaq-{project_name}-distillate.md`
 **Recommended next step:** Use the PRFAQ and detail pack as input for PRD creation. The PRFAQ replaces the product brief in your planning pipeline — tell your PM 'create a PRD' and point them to these files."
 **Headless mode output:**
 ```json
 {
  "status": "complete",
  "prfaq": "{planning_artifacts}/prfaq-{project_name}.md",
  "distillate": "{planning_artifacts}/prfaq-{project_name}-distillate.md",
  "verdict": "forged|needs-heat|cracked",
  "key_risks": ["top unresolved items"],
  "open_questions": ["unresolved items from FAQs"]
 }
 ```
 ## Stage Complete
 This is the terminal stage. If the user wants to revise, loop back to the relevant stage. Otherwise, the workflow is done.
--- a/src/bmm-skills/1-analysis/bmad-product-brief/SKILL.md
+++ b/src/bmm-skills/1-analysis/bmad-product-brief/SKILL.md
@ -37,7 +37,7 @@ Check activation context immediately:
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
-2. **Greet user** as `{user_name}`, speaking in `{communication_language}`. Be warm but efficient — dream builder energy.
+2. **Greet user** as `{user_name}`, speaking in `{communication_language}`.
 3. **Stage 1: Understand Intent** (handled here in SKILL.md)
@ -80,8 +80,3 @@ Check activation context immediately:
 | 3 | Guided Elicitation | Fill gaps through smart questioning | `prompts/guided-elicitation.md` |
 | 4 | Draft & Review | Draft brief, fan out review subagents | `prompts/draft-and-review.md` |
 | 5 | Finalize | Polish, output, offer distillate | `prompts/finalize.md` |
 ## External Skills
 This workflow uses:
 - `bmad-init` — Configuration loading (module: bmm)
--- a/src/bmm-skills/1-analysis/bmad-product-brief/bmad-manifest.json
+++ b/src/bmm-skills/1-analysis/bmad-product-brief/bmad-manifest.json
@ -8,7 +8,7 @@
      "description": "Produces executive product brief and optional LLM distillate for PRD input.",
      "supports-headless": true,
      "phase-name": "1-analysis",
-      "after": ["brainstorming, perform-research"],
+      "after": ["brainstorming", "perform-research"],
      "before": ["create-prd"],
      "is-required": true,
      "output-location": "{planning_artifacts}"
--- a/src/bmm-skills/1-analysis/research/bmad-domain-research/workflow.md
+++ b/src/bmm-skills/1-analysis/research/bmad-domain-research/workflow.md
@ -8,12 +8,14 @@
 **⛔ Web search required.** If unavailable, abort and tell the user.
-## CONFIGURATION
+## Activation
-Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve::
- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+   - Use `{user_name}` for greeting
- `communication_language`, `document_output_language`, `user_skill_level`
+   - Use `{communication_language}` for all communications
- `date` as a system-generated value
+   - Use `{document_output_language}` for output documents
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
 ## QUICK TOPIC DISCOVERY
--- a/src/bmm-skills/1-analysis/research/bmad-market-research/workflow.md
+++ b/src/bmm-skills/1-analysis/research/bmad-market-research/workflow.md
@ -8,12 +8,14 @@
 **⛔ Web search required.** If unavailable, abort and tell the user.
-## CONFIGURATION
+## Activation
-Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve::
- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+   - Use `{user_name}` for greeting
- `communication_language`, `document_output_language`, `user_skill_level`
+   - Use `{communication_language}` for all communications
- `date` as a system-generated value
+   - Use `{document_output_language}` for output documents
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
 ## QUICK TOPIC DISCOVERY
--- a/src/bmm-skills/1-analysis/research/bmad-technical-research/workflow.md
+++ b/src/bmm-skills/1-analysis/research/bmad-technical-research/workflow.md
@ -9,12 +9,14 @@
 **⛔ Web search required.** If unavailable, abort and tell the user.
-## CONFIGURATION
+## Activation
-Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve::
- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+   - Use `{user_name}` for greeting
- `communication_language`, `document_output_language`, `user_skill_level`
+   - Use `{communication_language}` for all communications
- `date` as a system-generated value
+   - Use `{document_output_language}` for output documents
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
 ## QUICK TOPIC DISCOVERY
--- a/src/bmm-skills/2-plan-workflows/bmad-agent-pm/SKILL.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-agent-pm/SKILL.md
@ -41,10 +41,12 @@ When you are in this persona and the user calls a skill, this persona must carry
 ## On Activation
-1. **Load config via bmad-init skill** — Store all returned vars for use:
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
-   - Use `{user_name}` from config for greeting
+   - Use `{user_name}` for greeting
-   - Use `{communication_language}` from config for all communications
+   - Use `{communication_language}` for all communications
-   - Store any other config variables as `{var-name}` and use appropriately
+   - Use `{document_output_language}` for output documents
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
 2. **Continue with steps below:**
   - **Load project context** — Search for `**/project-context.md`. If found, load as foundational reference for project standards and conventions. If not found, continue without it.
--- a/src/bmm-skills/2-plan-workflows/bmad-agent-ux-designer/SKILL.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-agent-ux-designer/SKILL.md
@ -37,10 +37,12 @@ When you are in this persona and the user calls a skill, this persona must carry
 ## On Activation
-1. **Load config via bmad-init skill** — Store all returned vars for use:
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
-   - Use `{user_name}` from config for greeting
+   - Use `{user_name}` for greeting
-   - Use `{communication_language}` from config for all communications
+   - Use `{communication_language}` for all communications
-   - Store any other config variables as `{var-name}` and use appropriately
+   - Use `{document_output_language}` for output documents
   - Use `{planning_artifacts}` for output location and artifact scanning
   - Use `{project_knowledge}` for additional context scanning
 2. **Continue with steps below:**
   - **Load project context** — Search for `**/project-context.md`. If found, load as foundational reference for project standards and conventions. If not found, continue without it.
--- a/src/bmm-skills/2-plan-workflows/bmad-create-prd/workflow.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-create-prd/workflow.md
@ -42,20 +42,19 @@ This uses **step-file architecture** for disciplined execution:
 - ⏸️ **ALWAYS** halt at menus and wait for user input
 - 📋 **NEVER** create mental todo lists from future steps
-## INITIALIZATION SEQUENCE
+## Activation
-### 1. Configuration Loading
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve::
-
+   - Use `{user_name}` for greeting
-Load and read full config from {main_config} and resolve:
+   - Use `{communication_language}` for all communications
-
+   - Use `{document_output_language}` for output documents
- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+   - Use `{planning_artifacts}` for output location and artifact scanning
- `communication_language`, `document_output_language`, `user_skill_level`
+   - Use `{project_knowledge}` for additional context scanning
 - `date` as system-generated current datetime
 ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the configured `{communication_language}`.
 ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`.
-### 2. Route to Create Workflow
+2. Route to Create Workflow
 "**Create Mode: Creating a new PRD from scratch.**"
--- a/src/bmm-skills/2-plan-workflows/bmad-create-ux-design/steps/step-13-responsive-accessibility.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-create-ux-design/steps/step-13-responsive-accessibility.md
@ -240,7 +240,7 @@ When user selects 'C', append the content directly to the document using the str
 ✅ Appropriate breakpoint strategy established
 ✅ Accessibility requirements determined and documented
 ✅ Comprehensive testing strategy planned
-✅ Implementation guidelines provided for development team
+✅ Implementation guidelines provided for Developer agent
 ✅ A/P/C menu presented and handled correctly
 ✅ Content properly appended to document when C selected
--- a/src/bmm-skills/2-plan-workflows/bmad-create-ux-design/workflow.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-create-ux-design/workflow.md
@ -15,15 +15,14 @@ This uses **micro-file architecture** for disciplined execution:
 ---
-## INITIALIZATION
+## Activation
-### Configuration Loading
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve::
-
+   - Use `{user_name}` for greeting
-Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+   - Use `{communication_language}` for all communications
-
+   - Use `{document_output_language}` for output documents
- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+   - Use `{planning_artifacts}` for output location and artifact scanning
- `communication_language`, `document_output_language`, `user_skill_level`
+   - Use `{project_knowledge}` for additional context scanning
 - `date` as system-generated current datetime
 ### Paths
--- a/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-01-discovery.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-01-discovery.md
@ -1,6 +1,6 @@
 ---
 # File references (ONLY variables used in this step)
-prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/create-prd/data/prd-purpose.md'
+prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-create-prd/data/prd-purpose.md'
 ---
 # Step E-1: Discovery & Understanding
--- a/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-01b-legacy-conversion.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-01b-legacy-conversion.md
@ -1,7 +1,7 @@
 ---
 # File references (ONLY variables used in this step)
 prdFile: '{prd_file_path}'
-prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/create-prd/data/prd-purpose.md'
+prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-create-prd/data/prd-purpose.md'
 ---
 # Step E-1B: Legacy PRD Conversion Assessment
--- a/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-02-review.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-02-review.md
@ -2,7 +2,7 @@
 # File references (ONLY variables used in this step)
 prdFile: '{prd_file_path}'
 validationReport: '{validation_report_path}'  # If provided
-prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/create-prd/data/prd-purpose.md'
+prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-create-prd/data/prd-purpose.md'
 ---
 # Step E-2: Deep Review & Analysis
--- a/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-03-edit.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-03-edit.md
@ -1,7 +1,7 @@
 ---
 # File references (ONLY variables used in this step)
 prdFile: '{prd_file_path}'
-prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/create-prd/data/prd-purpose.md'
+prdPurpose: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-create-prd/data/prd-purpose.md'
 ---
 # Step E-3: Edit & Update
--- a/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-04-complete.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-edit-prd/steps-e/step-e-04-complete.md
@ -1,7 +1,7 @@
 ---
 # File references (ONLY variables used in this step)
 prdFile: '{prd_file_path}'
-validationWorkflow: '{project-root}/_bmad/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-01-discovery.md'
+validationWorkflow: '{project-root}/_bmad/bmm-skills/2-plan-workflows/bmad-validate-prd/steps-v/step-v-01-discovery.md'
 ---
 # Step E-4: Complete & Validate
--- a/src/bmm-skills/2-plan-workflows/bmad-edit-prd/workflow.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-edit-prd/workflow.md
@ -41,20 +41,19 @@ This uses **step-file architecture** for disciplined execution:
 - ⏸️ **ALWAYS** halt at menus and wait for user input
 - 📋 **NEVER** create mental todo lists from future steps
-## INITIALIZATION SEQUENCE
+## Activation
-### 1. Configuration Loading
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve::
-
+   - Use `{user_name}` for greeting
-Load and read full config from {main_config} and resolve:
+   - Use `{communication_language}` for all communications
-
+   - Use `{document_output_language}` for output documents
- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+   - Use `{planning_artifacts}` for output location and artifact scanning
- `communication_language`, `document_output_language`, `user_skill_level`
+   - Use `{project_knowledge}` for additional context scanning
 - `date` as system-generated current datetime
 ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the configured `{communication_language}`.
 ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`.
-### 2. Route to Edit Workflow
+2. Route to Edit Workflow
 "**Edit Mode: Improving an existing PRD.**"
--- a/src/bmm-skills/2-plan-workflows/bmad-validate-prd/workflow.md
+++ b/src/bmm-skills/2-plan-workflows/bmad-validate-prd/workflow.md
@ -42,20 +42,19 @@ This uses **step-file architecture** for disciplined execution:
 - ⏸️ **ALWAYS** halt at menus and wait for user input
 - 📋 **NEVER** create mental todo lists from future steps
-## INITIALIZATION SEQUENCE
+## Activation
-### 1. Configuration Loading
+1. Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve::
-
+   - Use `{user_name}` for greeting
-Load and read full config from {main_config} and resolve:
+   - Use `{communication_language}` for all communications
-
+   - Use `{document_output_language}` for output documents
- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+   - Use `{planning_artifacts}` for output location and artifact scanning
- `communication_language`, `document_output_language`, `user_skill_level`
+   - Use `{project_knowledge}` for additional context scanning
 - `date` as system-generated current datetime
 ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the configured `{communication_language}`.
 ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`.
-### 2. Route to Validate Workflow
+2. Route to Validate Workflow
 "**Validate Mode: Validating an existing PRD against BMAD standards.**"
--- a/src/bmm-skills/2-plan-workflows/create-prd/data/domain-complexity.csv
+++ b/src/bmm-skills/2-plan-workflows/create-prd/data/domain-complexity.csv
@ -1,15 +0,0 @@
 domain,signals,complexity,key_concerns,required_knowledge,suggested_workflow,web_searches,special_sections
 healthcare,"medical,diagnostic,clinical,FDA,patient,treatment,HIPAA,therapy,pharma,drug",high,"FDA approval;Clinical validation;HIPAA compliance;Patient safety;Medical device classification;Liability","Regulatory pathways;Clinical trial design;Medical standards;Data privacy;Integration requirements","domain-research","FDA software medical device guidance {date};HIPAA compliance software requirements;Medical software standards {date};Clinical validation software","clinical_requirements;regulatory_pathway;validation_methodology;safety_measures"
 fintech,"payment,banking,trading,investment,crypto,wallet,transaction,KYC,AML,funds,fintech",high,"Regional compliance;Security standards;Audit requirements;Fraud prevention;Data protection","KYC/AML requirements;PCI DSS;Open banking;Regional laws (US/EU/APAC);Crypto regulations","domain-research","fintech regulations {date};payment processing compliance {date};open banking API standards;cryptocurrency regulations {date}","compliance_matrix;security_architecture;audit_requirements;fraud_prevention"
 govtech,"government,federal,civic,public sector,citizen,municipal,voting",high,"Procurement rules;Security clearance;Accessibility (508);FedRAMP;Privacy;Transparency","Government procurement;Security frameworks;Accessibility standards;Privacy laws;Open data requirements","domain-research","government software procurement {date};FedRAMP compliance requirements;section 508 accessibility;government security standards","procurement_compliance;security_clearance;accessibility_standards;transparency_requirements"
 edtech,"education,learning,student,teacher,curriculum,assessment,K-12,university,LMS",medium,"Student privacy (COPPA/FERPA);Accessibility;Content moderation;Age verification;Curriculum standards","Educational privacy laws;Learning standards;Accessibility requirements;Content guidelines;Assessment validity","domain-research","educational software privacy {date};COPPA FERPA compliance;WCAG education requirements;learning management standards","privacy_compliance;content_guidelines;accessibility_features;curriculum_alignment"
 aerospace,"aircraft,spacecraft,aviation,drone,satellite,propulsion,flight,radar,navigation",high,"Safety certification;DO-178C compliance;Performance validation;Simulation accuracy;Export controls","Aviation standards;Safety analysis;Simulation validation;ITAR/export controls;Performance requirements","domain-research + technical-model","DO-178C software certification;aerospace simulation standards {date};ITAR export controls software;aviation safety requirements","safety_certification;simulation_validation;performance_requirements;export_compliance"
 automotive,"vehicle,car,autonomous,ADAS,automotive,driving,EV,charging",high,"Safety standards;ISO 26262;V2X communication;Real-time requirements;Certification","Automotive standards;Functional safety;V2X protocols;Real-time systems;Testing requirements","domain-research","ISO 26262 automotive software;automotive safety standards {date};V2X communication protocols;EV charging standards","safety_standards;functional_safety;communication_protocols;certification_requirements"
 scientific,"research,algorithm,simulation,modeling,computational,analysis,data science,ML,AI",medium,"Reproducibility;Validation methodology;Peer review;Performance;Accuracy;Computational resources","Scientific method;Statistical validity;Computational requirements;Domain expertise;Publication standards","technical-model","scientific computing best practices {date};research reproducibility standards;computational modeling validation;peer review software","validation_methodology;accuracy_metrics;reproducibility_plan;computational_requirements"
 legaltech,"legal,law,contract,compliance,litigation,patent,attorney,court",high,"Legal ethics;Bar regulations;Data retention;Attorney-client privilege;Court system integration","Legal practice rules;Ethics requirements;Court filing systems;Document standards;Confidentiality","domain-research","legal technology ethics {date};law practice management software requirements;court filing system standards;attorney client privilege technology","ethics_compliance;data_retention;confidentiality_measures;court_integration"
 insuretech,"insurance,claims,underwriting,actuarial,policy,risk,premium",high,"Insurance regulations;Actuarial standards;Data privacy;Fraud detection;State compliance","Insurance regulations by state;Actuarial methods;Risk modeling;Claims processing;Regulatory reporting","domain-research","insurance software regulations {date};actuarial standards software;insurance fraud detection;state insurance compliance","regulatory_requirements;risk_modeling;fraud_detection;reporting_compliance"
 energy,"energy,utility,grid,solar,wind,power,electricity,oil,gas",high,"Grid compliance;NERC standards;Environmental regulations;Safety requirements;Real-time operations","Energy regulations;Grid standards;Environmental compliance;Safety protocols;SCADA systems","domain-research","energy sector software compliance {date};NERC CIP standards;smart grid requirements;renewable energy software standards","grid_compliance;safety_protocols;environmental_compliance;operational_requirements"
 process_control,"industrial automation,process control,PLC,SCADA,DCS,HMI,operational technology,OT,control system,cyberphysical,MES,historian,instrumentation,I&C,P&ID",high,"Functional safety;OT cybersecurity;Real-time control requirements;Legacy system integration;Process safety and hazard analysis;Environmental compliance and permitting;Engineering authority and PE requirements","Functional safety standards;OT security frameworks;Industrial protocols;Process control architecture;Plant reliability and maintainability","domain-research + technical-model","IEC 62443 OT cybersecurity requirements {date};functional safety software requirements {date};industrial process control architecture;ISA-95 manufacturing integration","functional_safety;ot_security;process_requirements;engineering_authority"
 building_automation,"building automation,BAS,BMS,HVAC,smart building,lighting control,fire alarm,fire protection,fire suppression,life safety,elevator,access control,DDC,energy management,sequence of operations,commissioning",high,"Life safety codes;Building energy standards;Multi-trade coordination and interoperability;Commissioning and ongoing operational performance;Indoor environmental quality and occupant comfort;Engineering authority and PE requirements","Building automation protocols;HVAC and mechanical controls;Fire alarm, fire protection, and life safety design;Commissioning process and sequence of operations;Building codes and energy standards","domain-research","smart building software architecture {date};BACnet integration best practices;building automation cybersecurity {date};ASHRAE building standards","life_safety;energy_compliance;commissioning_requirements;engineering_authority"
 gaming,"game,player,gameplay,level,character,multiplayer,quest",redirect,"REDIRECT TO GAME WORKFLOWS","Game design","game-brief","NA","NA"
 general,"",low,"Standard requirements;Basic security;User experience;Performance","General software practices","continue","software development best practices {date}","standard_requirements"
--- a/src/bmm-skills/2-plan-workflows/create-prd/data/prd-purpose.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/data/prd-purpose.md
@ -1,197 +0,0 @@
 # BMAD PRD Purpose
 **The PRD is the top of the required funnel that feeds all subsequent product development work in rhw BMad Method.**
 ---
 ## What is a BMAD PRD?
 A dual-audience document serving:
 1. **Human Product Managers and builders** - Vision, strategy, stakeholder communication
 2. **LLM Downstream Consumption** - UX Design → Architecture → Epics → Development AI Agents
 Each successive document becomes more AI-tailored and granular.
 ---
 ## Core Philosophy: Information Density
 **High Signal-to-Noise Ratio**
 Every sentence must carry information weight. LLMs consume precise, dense content efficiently.
 **Anti-Patterns (Eliminate These):**
 - ❌ "The system will allow users to..." → ✅ "Users can..."
 - ❌ "It is important to note that..." → ✅ State the fact directly
 - ❌ "In order to..." → ✅ "To..."
 - ❌ Conversational filler and padding → ✅ Direct, concise statements
 **Goal:** Maximum information per word. Zero fluff.
 ---
 ## The Traceability Chain
 **PRD starts the chain:**
 ```
 Vision → Success Criteria → User Journeys → Functional Requirements → (future: User Stories)
 ```
 **In the PRD, establish:**
 - Vision → Success Criteria alignment
 - Success Criteria → User Journey coverage
 - User Journey → Functional Requirement mapping
 - All requirements traceable to user needs
 **Why:** Each downstream artifact (UX, Architecture, Epics, Stories) must trace back to documented user needs and business objectives. This chain ensures we build the right thing.
 ---
 ## What Makes Great Functional Requirements?
 ### FRs are Capabilities, Not Implementation
 **Good FR:** "Users can reset their password via email link"
 **Bad FR:** "System sends JWT via email and validates with database" (implementation leakage)
 **Good FR:** "Dashboard loads in under 2 seconds for 95th percentile"
 **Bad FR:** "Fast loading time" (subjective, unmeasurable)
 ### SMART Quality Criteria
 **Specific:** Clear, precisely defined capability
 **Measurable:** Quantifiable with test criteria
 **Attainable:** Realistic within constraints
 **Relevant:** Aligns with business objectives
 **Traceable:** Links to source (executive summary or user journey)
 ### FR Anti-Patterns
 **Subjective Adjectives:**
 - ❌ "easy to use", "intuitive", "user-friendly", "fast", "responsive"
 - ✅ Use metrics: "completes task in under 3 clicks", "loads in under 2 seconds"
 **Implementation Leakage:**
 - ❌ Technology names, specific libraries, implementation details
 - ✅ Focus on capability and measurable outcomes
 **Vague Quantifiers:**
 - ❌ "multiple users", "several options", "various formats"
 - ✅ "up to 100 concurrent users", "3-5 options", "PDF, DOCX, TXT formats"
 **Missing Test Criteria:**
 - ❌ "The system shall provide notifications"
 - ✅ "The system shall send email notifications within 30 seconds of trigger event"
 ---
 ## What Makes Great Non-Functional Requirements?
 ### NFRs Must Be Measurable
 **Template:**
 ```
 "The system shall [metric] [condition] [measurement method]"
 ```
 **Examples:**
 - ✅ "The system shall respond to API requests in under 200ms for 95th percentile as measured by APM monitoring"
 - ✅ "The system shall maintain 99.9% uptime during business hours as measured by cloud provider SLA"
 - ✅ "The system shall support 10,000 concurrent users as measured by load testing"
 ### NFR Anti-Patterns
 **Unmeasurable Claims:**
 - ❌ "The system shall be scalable" → ✅ "The system shall handle 10x load growth through horizontal scaling"
 - ❌ "High availability required" → ✅ "99.9% uptime as measured by cloud provider SLA"
 **Missing Context:**
 - ❌ "Response time under 1 second" → ✅ "API response time under 1 second for 95th percentile under normal load"
 ---
 ## Domain-Specific Requirements
 **Auto-Detect and Enforce Based on Project Context**
 Certain industries have mandatory requirements that must be present:
 - **Healthcare:** HIPAA Privacy & Security Rules, PHI encryption, audit logging, MFA
 - **Fintech:** PCI-DSS Level 1, AML/KYC compliance, SOX controls, financial audit trails
 - **GovTech:** NIST framework, Section 508 accessibility (WCAG 2.1 AA), FedRAMP, data residency
 - **E-Commerce:** PCI-DSS for payments, inventory accuracy, tax calculation by jurisdiction
 **Why:** Missing these requirements in the PRD means they'll be missed in architecture and implementation, creating expensive rework. During PRD creation there is a step to cover this - during validation we want to make sure it was covered. For this purpose steps will utilize a domain-complexity.csv and project-types.csv.
 ---
 ## Document Structure (Markdown, Human-Readable)
 ### Required Sections
 1. **Executive Summary** - Vision, differentiator, target users
 2. **Success Criteria** - Measurable outcomes (SMART)
 3. **Product Scope** - MVP, Growth, Vision phases
 4. **User Journeys** - Comprehensive coverage
 5. **Domain Requirements** - Industry-specific compliance (if applicable)
 6. **Innovation Analysis** - Competitive differentiation (if applicable)
 7. **Project-Type Requirements** - Platform-specific needs
 8. **Functional Requirements** - Capability contract (FRs)
 9. **Non-Functional Requirements** - Quality attributes (NFRs)
 ### Formatting for Dual Consumption
 **For Humans:**
 - Clear, professional language
 - Logical flow from vision to requirements
 - Easy for stakeholders to review and approve
 **For LLMs:**
 - ## Level 2 headers for all main sections (enables extraction)
 - Consistent structure and patterns
 - Precise, testable language
 - High information density
 ---
 ## Downstream Impact
 **How the PRD Feeds Next Artifacts:**
 **UX Design:**
 - User journeys → interaction flows
 - FRs → design requirements
 - Success criteria → UX metrics
 **Architecture:**
 - FRs → system capabilities
 - NFRs → architecture decisions
 - Domain requirements → compliance architecture
 - Project-type requirements → platform choices
 **Epics & Stories (created after architecture):**
 - FRs → user stories (1 FR could map to 1-3 stories potentially)
 - Acceptance criteria → story acceptance tests
 - Priority → sprint sequencing
 - Traceability → stories map back to vision
 **Development AI Agents:**
 - Precise requirements → implementation clarity
 - Test criteria → automated test generation
 - Domain requirements → compliance enforcement
 - Measurable NFRs → performance targets
 ---
 ## Summary: What Makes a Great BMAD PRD?
 ✅ **High Information Density** - Every sentence carries weight, zero fluff
 ✅ **Measurable Requirements** - All FRs and NFRs are testable with specific criteria
 ✅ **Clear Traceability** - Each requirement links to user need and business objective
 ✅ **Domain Awareness** - Industry-specific requirements auto-detected and included
 ✅ **Zero Anti-Patterns** - No subjective adjectives, implementation leakage, or vague quantifiers
 ✅ **Dual Audience Optimized** - Human-readable AND LLM-consumable
 ✅ **Markdown Format** - Professional, clean, accessible to all stakeholders
 ---
 **Remember:** The PRD is the foundation. Quality here ripples through every subsequent phase. A dense, precise, well-traced PRD makes UX design, architecture, epic breakdown, and AI development dramatically more effective.
--- a/src/bmm-skills/2-plan-workflows/create-prd/data/project-types.csv
+++ b/src/bmm-skills/2-plan-workflows/create-prd/data/project-types.csv
@ -1,11 +0,0 @@
 project_type,detection_signals,key_questions,required_sections,skip_sections,web_search_triggers,innovation_signals
 api_backend,"API,REST,GraphQL,backend,service,endpoints","Endpoints needed?;Authentication method?;Data formats?;Rate limits?;Versioning?;SDK needed?","endpoint_specs;auth_model;data_schemas;error_codes;rate_limits;api_docs","ux_ui;visual_design;user_journeys","framework best practices;OpenAPI standards","API composition;New protocol"
 mobile_app,"iOS,Android,app,mobile,iPhone,iPad","Native or cross-platform?;Offline needed?;Push notifications?;Device features?;Store compliance?","platform_reqs;device_permissions;offline_mode;push_strategy;store_compliance","desktop_features;cli_commands","app store guidelines;platform requirements","Gesture innovation;AR/VR features"
 saas_b2b,"SaaS,B2B,platform,dashboard,teams,enterprise","Multi-tenant?;Permission model?;Subscription tiers?;Integrations?;Compliance?","tenant_model;rbac_matrix;subscription_tiers;integration_list;compliance_reqs","cli_interface;mobile_first","compliance requirements;integration guides","Workflow automation;AI agents"
 developer_tool,"SDK,library,package,npm,pip,framework","Language support?;Package managers?;IDE integration?;Documentation?;Examples?","language_matrix;installation_methods;api_surface;code_examples;migration_guide","visual_design;store_compliance","package manager best practices;API design patterns","New paradigm;DSL creation"
 cli_tool,"CLI,command,terminal,bash,script","Interactive or scriptable?;Output formats?;Config method?;Shell completion?","command_structure;output_formats;config_schema;scripting_support","visual_design;ux_principles;touch_interactions","CLI design patterns;shell integration","Natural language CLI;AI commands"
 web_app,"website,webapp,browser,SPA,PWA","SPA or MPA?;Browser support?;SEO needed?;Real-time?;Accessibility?","browser_matrix;responsive_design;performance_targets;seo_strategy;accessibility_level","native_features;cli_commands","web standards;WCAG guidelines","New interaction;WebAssembly use"
 game,"game,player,gameplay,level,character","REDIRECT TO USE THE BMad Method Game Module Agent and Workflows - HALT","game-brief;GDD","most_sections","game design patterns","Novel mechanics;Genre mixing"
 desktop_app,"desktop,Windows,Mac,Linux,native","Cross-platform?;Auto-update?;System integration?;Offline?","platform_support;system_integration;update_strategy;offline_capabilities","web_seo;mobile_features","desktop guidelines;platform requirements","Desktop AI;System automation"
 iot_embedded,"IoT,embedded,device,sensor,hardware","Hardware specs?;Connectivity?;Power constraints?;Security?;OTA updates?","hardware_reqs;connectivity_protocol;power_profile;security_model;update_mechanism","visual_ui;browser_support","IoT standards;protocol specs","Edge AI;New sensors"
 blockchain_web3,"blockchain,crypto,DeFi,NFT,smart contract","Chain selection?;Wallet integration?;Gas optimization?;Security audit?","chain_specs;wallet_support;smart_contracts;security_audit;gas_optimization","traditional_auth;centralized_db","blockchain standards;security patterns","Novel tokenomics;DAO structure"
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-01-discovery.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-01-discovery.md
@ -1,224 +0,0 @@
 ---
 name: 'step-v-01-discovery'
 description: 'Document Discovery & Confirmation - Handle fresh context validation, confirm PRD path, discover input documents'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-02-format-detection.md'
 prdPurpose: '../data/prd-purpose.md'
 ---
 # Step 1: Document Discovery & Confirmation
 ## STEP GOAL:
 Handle fresh context validation by confirming PRD path, discovering and loading input documents from frontmatter, and initializing the validation report.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in collaborative dialogue, not command-response
 - ✅ You bring systematic validation expertise and analytical rigor
 - ✅ User brings domain knowledge and specific PRD context
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on discovering PRD and input documents, not validating yet
 - 🚫 FORBIDDEN to perform any validation checks in this step
 - 💬 Approach: Systematic discovery with clear reporting to user
 - 🚪 This is the setup step - get everything ready for validation
 ## EXECUTION PROTOCOLS:
 - 🎯 Discover and confirm PRD to validate
 - 💾 Load PRD and all input documents from frontmatter
 - 📖 Initialize validation report next to PRD
 - 🚫 FORBIDDEN to load next step until user confirms setup
 ## CONTEXT BOUNDARIES:
 - Available context: PRD path (user-specified or discovered), workflow configuration
 - Focus: Document discovery and setup only
 - Limits: Don't perform validation, don't skip discovery
 - Dependencies: Configuration loaded from PRD workflow.md initialization
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Load PRD Purpose and Standards
 Load and read the complete file at:
 `{prdPurpose}`
 This file contains the BMAD PRD philosophy, standards, and validation criteria that will guide all validation checks. Internalize this understanding - it defines what makes a great BMAD PRD.
 ### 2. Discover PRD to Validate
 **If PRD path provided as invocation parameter:**
 - Use provided path
 **If no PRD path provided, auto-discover:**
 - Search `{planning_artifacts}` for files matching `*prd*.md`
 - Also check for sharded PRDs: `{planning_artifacts}/*prd*/*.md`
 **If exactly ONE PRD found:**
 - Use it automatically
 - Inform user: "Found PRD: {discovered_path} — using it for validation."
 **If MULTIPLE PRDs found:**
 - List all discovered PRDs with numbered options
 - "I found multiple PRDs. Which one would you like to validate?"
 - Wait for user selection
 **If NO PRDs found:**
 - "I couldn't find any PRD files in {planning_artifacts}. Please provide the path to the PRD file you want to validate."
 - Wait for user to provide PRD path.
 ### 3. Validate PRD Exists and Load
 Once PRD path is provided:
 - Check if PRD file exists at specified path
 - If not found: "I cannot find a PRD at that path. Please check the path and try again."
 - If found: Load the complete PRD file including frontmatter
 ### 4. Extract Frontmatter and Input Documents
 From the loaded PRD frontmatter, extract:
 - `inputDocuments: []` array (if present)
 - Any other relevant metadata (classification, date, etc.)
 **If no inputDocuments array exists:**
 Note this and proceed with PRD-only validation
 ### 5. Load Input Documents
 For each document listed in `inputDocuments`:
 - Attempt to load the document
 - Track successfully loaded documents
 - Note any documents that fail to load
 **Build list of loaded input documents:**
 - Product Brief (if present)
 - Research documents (if present)
 - Other reference materials (if present)
 ### 6. Ask About Additional Reference Documents
 "**I've loaded the following documents from your PRD frontmatter:**
 {list loaded documents with file names}
 **Are there any additional reference documents you'd like me to include in this validation?**
 These could include:
 - Additional research or context documents
 - Project documentation not tracked in frontmatter
 - Standards or compliance documents
 - Competitive analysis or benchmarks
 Please provide paths to any additional documents, or type 'none' to proceed."
 **Load any additional documents provided by user.**
 ### 7. Initialize Validation Report
 Create validation report at: `{validationReportPath}`
 **Initialize with frontmatter:**
 ```yaml
 ---
 validationTarget: '{prd_path}'
 validationDate: '{current_date}'
 inputDocuments: [list of all loaded documents]
 validationStepsCompleted: []
 validationStatus: IN_PROGRESS
 ---
 ```
 **Initial content:**
 ```markdown
 # PRD Validation Report
 **PRD Being Validated:** {prd_path}
 **Validation Date:** {current_date}
 ## Input Documents
 {list all documents loaded for validation}
 ## Validation Findings
 [Findings will be appended as validation progresses]
 ```
 ### 8. Present Discovery Summary
 "**Setup Complete!**
 **PRD to Validate:** {prd_path}
 **Input Documents Loaded:**
 - PRD: {prd_name} ✓
 - Product Brief: {count} {if count > 0}✓{else}(none found){/if}
 - Research: {count} {if count > 0}✓{else}(none found){/if}
 - Additional References: {count} {if count > 0}✓{else}(none){/if}
 **Validation Report:** {validationReportPath}
 **Ready to begin validation.**"
 ### 9. Present MENU OPTIONS
 Display: **Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Format Detection
 #### EXECUTION RULES:
 - ALWAYS halt and wait for user input after presenting menu
 - ONLY proceed to next step when user selects 'C'
 - User can ask questions or add more documents - always respond and redisplay menu
 #### Menu Handling Logic:
 - IF A: Invoke the `bmad-advanced-elicitation` skill, and when finished redisplay the menu
 - IF P: Invoke the `bmad-party-mode` skill, and when finished redisplay the menu
 - IF C: Read fully and follow: {nextStepFile} to begin format detection
 - IF user provides additional document: Load it, update report, redisplay summary
 - IF Any other: help user, then redisplay menu
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - PRD path discovered and confirmed
 - PRD file exists and loads successfully
 - All input documents from frontmatter loaded
 - Additional reference documents (if any) loaded
 - Validation report initialized next to PRD
 - User clearly informed of setup status
 - Menu presented and user input handled correctly
 ### ❌ SYSTEM FAILURE:
 - Proceeding with non-existent PRD file
 - Not loading input documents from frontmatter
 - Creating validation report in wrong location
 - Proceeding without user confirming setup
 - Not handling missing input documents gracefully
 **Master Rule:** Complete discovery and setup BEFORE validation. This step ensures everything is in place for systematic validation checks.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-02-format-detection.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-02-format-detection.md
@ -1,191 +0,0 @@
 ---
 name: 'step-v-02-format-detection'
 description: 'Format Detection & Structure Analysis - Classify PRD format and route appropriately'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-03-density-validation.md'
 altStepFile: './step-v-02b-parity-check.md'
 prdFile: '{prd_file_path}'
 validationReportPath: '{validation_report_path}'
 ---
 # Step 2: Format Detection & Structure Analysis
 ## STEP GOAL:
 Detect if PRD follows BMAD format and route appropriately - classify as BMAD Standard / BMAD Variant / Non-Standard, with optional parity check for non-standard formats.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in collaborative dialogue, not command-response
 - ✅ You bring systematic validation expertise and pattern recognition
 - ✅ User brings domain knowledge and PRD context
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on detecting format and classifying structure
 - 🚫 FORBIDDEN to perform other validation checks in this step
 - 💬 Approach: Analytical and systematic, clear reporting of findings
 - 🚪 This is a branch step - may route to parity check for non-standard PRDs
 ## EXECUTION PROTOCOLS:
 - 🎯 Analyze PRD structure systematically
 - 💾 Append format findings to validation report
 - 📖 Route appropriately based on format classification
 - 🚫 FORBIDDEN to skip format detection or proceed without classification
 ## CONTEXT BOUNDARIES:
 - Available context: PRD file loaded in step 1, validation report initialized
 - Focus: Format detection and classification only
 - Limits: Don't perform other validation, don't skip classification
 - Dependencies: Step 1 completed - PRD loaded and report initialized
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Extract PRD Structure
 Load the complete PRD file and extract:
 **All Level 2 (##) headers:**
 - Scan through entire PRD document
 - Extract all ## section headers
 - List them in order
 **PRD frontmatter:**
 - Extract classification.domain if present
 - Extract classification.projectType if present
 - Note any other relevant metadata
 ### 2. Check for BMAD PRD Core Sections
 Check if the PRD contains the following BMAD PRD core sections:
 1. **Executive Summary** (or variations: ## Executive Summary, ## Overview, ## Introduction)
 2. **Success Criteria** (or: ## Success Criteria, ## Goals, ## Objectives)
 3. **Product Scope** (or: ## Product Scope, ## Scope, ## In Scope, ## Out of Scope)
 4. **User Journeys** (or: ## User Journeys, ## User Stories, ## User Flows)
 5. **Functional Requirements** (or: ## Functional Requirements, ## Features, ## Capabilities)
 6. **Non-Functional Requirements** (or: ## Non-Functional Requirements, ## NFRs, ## Quality Attributes)
 **Count matches:**
 - How many of these 6 core sections are present?
 - Which specific sections are present?
 - Which are missing?
 ### 3. Classify PRD Format
 Based on core section count, classify:
 **BMAD Standard:**
 - 5-6 core sections present
 - Follows BMAD PRD structure closely
 **BMAD Variant:**
 - 3-4 core sections present
 - Generally follows BMAD patterns but may have structural differences
 - Missing some sections but recognizable as BMAD-style
 **Non-Standard:**
 - Fewer than 3 core sections present
 - Does not follow BMAD PRD structure
 - May be completely custom format, legacy format, or from another framework
 ### 4. Report Format Findings to Validation Report
 Append to validation report:
 ```markdown
 ## Format Detection
 **PRD Structure:**
 [List all ## Level 2 headers found]
 **BMAD Core Sections Present:**
 - Executive Summary: [Present/Missing]
 - Success Criteria: [Present/Missing]
 - Product Scope: [Present/Missing]
 - User Journeys: [Present/Missing]
 - Functional Requirements: [Present/Missing]
 - Non-Functional Requirements: [Present/Missing]
 **Format Classification:** [BMAD Standard / BMAD Variant / Non-Standard]
 **Core Sections Present:** [count]/6
 ```
 ### 5. Route Based on Format Classification
 **IF format is BMAD Standard or BMAD Variant:**
 Display: "**Format Detected:** {classification}
 Proceeding to systematic validation checks..."
 Without delay, read fully and follow: {nextStepFile} (step-v-03-density-validation.md)
 **IF format is Non-Standard (< 3 core sections):**
 Display: "**Format Detected:** Non-Standard PRD
 This PRD does not follow BMAD standard structure (only {count}/6 core sections present).
 You have options:"
 Present MENU OPTIONS below for user selection
 ### 6. Present MENU OPTIONS (Non-Standard PRDs Only)
 **[A] Parity Check** - Analyze gaps and estimate effort to reach BMAD PRD parity
 **[B] Validate As-Is** - Proceed with validation using current structure
 **[C] Exit** - Exit validation and review format findings
 #### EXECUTION RULES:
 - ALWAYS halt and wait for user input
 - Only proceed based on user selection
 #### Menu Handling Logic:
 - IF A (Parity Check): Read fully and follow: {altStepFile} (step-v-02b-parity-check.md)
 - IF B (Validate As-Is): Display "Proceeding with validation..." then read fully and follow: {nextStepFile}
 - IF C (Exit): Display format findings summary and exit validation
 - IF Any other: help user respond, then redisplay menu
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - All ## Level 2 headers extracted successfully
 - BMAD core sections checked systematically
 - Format classified correctly based on section count
 - Findings reported to validation report
 - BMAD Standard/Variant PRDs proceed directly to next validation step
 - Non-Standard PRDs pause and present options to user
 - User can choose parity check, validate as-is, or exit
 ### ❌ SYSTEM FAILURE:
 - Not extracting all headers before classification
 - Incorrect format classification
 - Not reporting findings to validation report
 - Not pausing for non-standard PRDs
 - Proceeding without user decision for non-standard formats
 **Master Rule:** Format detection determines validation path. Non-standard PRDs require user choice before proceeding.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-02b-parity-check.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-02b-parity-check.md
@ -1,209 +0,0 @@
 ---
 name: 'step-v-02b-parity-check'
 description: 'Document Parity Check - Analyze non-standard PRD and identify gaps to achieve BMAD PRD parity'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-03-density-validation.md'
 prdFile: '{prd_file_path}'
 validationReportPath: '{validation_report_path}'
 ---
 # Step 2B: Document Parity Check
 ## STEP GOAL:
 Analyze non-standard PRD and identify gaps to achieve BMAD PRD parity, presenting user with options for how to proceed.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in collaborative dialogue, not command-response
 - ✅ You bring BMAD PRD standards expertise and gap analysis
 - ✅ User brings domain knowledge and PRD context
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on analyzing gaps and estimating parity effort
 - 🚫 FORBIDDEN to perform other validation checks in this step
 - 💬 Approach: Systematic gap analysis with clear recommendations
 - 🚪 This is an optional branch step - user chooses next action
 ## EXECUTION PROTOCOLS:
 - 🎯 Analyze each BMAD PRD section for gaps
 - 💾 Append parity analysis to validation report
 - 📖 Present options and await user decision
 - 🚫 FORBIDDEN to proceed without user selection
 ## CONTEXT BOUNDARIES:
 - Available context: Non-standard PRD from step 2, validation report in progress
 - Focus: Parity analysis only - what's missing, what's needed
 - Limits: Don't perform validation checks, don't auto-proceed
 - Dependencies: Step 2 classified PRD as non-standard and user chose parity check
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Analyze Each BMAD PRD Section
 For each of the 6 BMAD PRD core sections, analyze:
 **Executive Summary:**
 - Does PRD have vision/overview?
 - Is problem statement clear?
 - Are target users identified?
 - Gap: [What's missing or incomplete]
 **Success Criteria:**
 - Are measurable goals defined?
 - Is success clearly defined?
 - Gap: [What's missing or incomplete]
 **Product Scope:**
 - Is scope clearly defined?
 - Are in-scope items listed?
 - Are out-of-scope items listed?
 - Gap: [What's missing or incomplete]
 **User Journeys:**
 - Are user types/personas identified?
 - Are user flows documented?
 - Gap: [What's missing or incomplete]
 **Functional Requirements:**
 - Are features/capabilities listed?
 - Are requirements structured?
 - Gap: [What's missing or incomplete]
 **Non-Functional Requirements:**
 - Are quality attributes defined?
 - Are performance/security/etc. requirements documented?
 - Gap: [What's missing or incomplete]
 ### 2. Estimate Effort to Reach Parity
 For each missing or incomplete section, estimate:
 **Effort Level:**
 - Minimal - Section exists but needs minor enhancements
 - Moderate - Section missing but content exists elsewhere in PRD
 - Significant - Section missing, requires new content creation
 **Total Parity Effort:**
 - Based on individual section estimates
 - Classify overall: Quick / Moderate / Substantial effort
 ### 3. Report Parity Analysis to Validation Report
 Append to validation report:
 ```markdown
 ## Parity Analysis (Non-Standard PRD)
 ### Section-by-Section Gap Analysis
 **Executive Summary:**
 - Status: [Present/Missing/Incomplete]
 - Gap: [specific gap description]
 - Effort to Complete: [Minimal/Moderate/Significant]
 **Success Criteria:**
 - Status: [Present/Missing/Incomplete]
 - Gap: [specific gap description]
 - Effort to Complete: [Minimal/Moderate/Significant]
 **Product Scope:**
 - Status: [Present/Missing/Incomplete]
 - Gap: [specific gap description]
 - Effort to Complete: [Minimal/Moderate/Significant]
 **User Journeys:**
 - Status: [Present/Missing/Incomplete]
 - Gap: [specific gap description]
 - Effort to Complete: [Minimal/Moderate/Significant]
 **Functional Requirements:**
 - Status: [Present/Missing/Incomplete]
 - Gap: [specific gap description]
 - Effort to Complete: [Minimal/Moderate/Significant]
 **Non-Functional Requirements:**
 - Status: [Present/Missing/Incomplete]
 - Gap: [specific gap description]
 - Effort to Complete: [Minimal/Moderate/Significant]
 ### Overall Parity Assessment
 **Overall Effort to Reach BMAD Standard:** [Quick/Moderate/Substantial]
 **Recommendation:** [Brief recommendation based on analysis]
 ```
 ### 4. Present Parity Analysis and Options
 Display:
 "**Parity Analysis Complete**
 Your PRD is missing {count} of 6 core BMAD PRD sections. The overall effort to reach BMAD standard is: **{effort level}**
 **Quick Summary:**
 [2-3 sentence summary of key gaps]
 **Recommendation:**
 {recommendation from analysis}
 **How would you like to proceed?**"
 ### 5. Present MENU OPTIONS
 **[C] Continue Validation** - Proceed with validation using current structure
 **[E] Exit & Review** - Exit validation and review parity report
 **[S] Save & Exit** - Save parity report and exit
 #### EXECUTION RULES:
 - ALWAYS halt and wait for user input
 - Only proceed based on user selection
 #### Menu Handling Logic:
 - IF C (Continue): Display "Proceeding with validation..." then read fully and follow: {nextStepFile}
 - IF E (Exit): Display parity summary and exit validation
 - IF S (Save): Confirm saved, display summary, exit
 - IF Any other: help user respond, then redisplay menu
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - All 6 BMAD PRD sections analyzed for gaps
 - Effort estimates provided for each gap
 - Overall parity effort assessed correctly
 - Parity analysis reported to validation report
 - Clear summary presented to user
 - User can choose to continue validation, exit, or save report
 ### ❌ SYSTEM FAILURE:
 - Not analyzing all 6 sections systematically
 - Missing effort estimates
 - Not reporting parity analysis to validation report
 - Auto-proceeding without user decision
 - Unclear recommendations
 **Master Rule:** Parity check informs user of gaps and effort, but user decides whether to proceed with validation or address gaps first.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-03-density-validation.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-03-density-validation.md
@ -1,174 +0,0 @@
 ---
 name: 'step-v-03-density-validation'
 description: 'Information Density Check - Scan for anti-patterns that violate information density principles'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-04-brief-coverage-validation.md'
 prdFile: '{prd_file_path}'
 validationReportPath: '{validation_report_path}'
 ---
 # Step 3: Information Density Validation
 ## STEP GOAL:
 Validate PRD meets BMAD information density standards by scanning for conversational filler, wordy phrases, and redundant expressions that violate conciseness principles.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in systematic validation, not collaborative dialogue
 - ✅ You bring analytical rigor and attention to detail
 - ✅ This step runs autonomously - no user input needed
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on information density anti-patterns
 - 🚫 FORBIDDEN to validate other aspects in this step
 - 💬 Approach: Systematic scanning and categorization
 - 🚪 This is a validation sequence step - auto-proceeds when complete
 ## EXECUTION PROTOCOLS:
 - 🎯 Scan PRD for density anti-patterns systematically
 - 💾 Append density findings to validation report
 - 📖 Display "Proceeding to next check..." and load next step
 - 🚫 FORBIDDEN to pause or request user input
 ## CONTEXT BOUNDARIES:
 - Available context: PRD file, validation report with format findings
 - Focus: Information density validation only
 - Limits: Don't validate other aspects, don't pause for user input
 - Dependencies: Step 2 completed - format classification done
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Attempt Sub-Process Validation
 **Try to use Task tool to spawn a subprocess:**
 "Perform information density validation on this PRD:
 1. Load the PRD file
 2. Scan for the following anti-patterns:
   - Conversational filler phrases (examples: 'The system will allow users to...', 'It is important to note that...', 'In order to')
   - Wordy phrases (examples: 'Due to the fact that', 'In the event of', 'For the purpose of')
   - Redundant phrases (examples: 'Future plans', 'Absolutely essential', 'Past history')
 3. Count violations by category with line numbers
 4. Classify severity: Critical (>10 violations), Warning (5-10), Pass (<5)
 Return structured findings with counts and examples."
 ### 2. Graceful Degradation (if Task tool unavailable)
 If Task tool unavailable, perform analysis directly:
 **Scan for conversational filler patterns:**
 - "The system will allow users to..."
 - "It is important to note that..."
 - "In order to"
 - "For the purpose of"
 - "With regard to"
 - Count occurrences and note line numbers
 **Scan for wordy phrases:**
 - "Due to the fact that" (use "because")
 - "In the event of" (use "if")
 - "At this point in time" (use "now")
 - "In a manner that" (use "how")
 - Count occurrences and note line numbers
 **Scan for redundant phrases:**
 - "Future plans" (just "plans")
 - "Past history" (just "history")
 - "Absolutely essential" (just "essential")
 - "Completely finish" (just "finish")
 - Count occurrences and note line numbers
 ### 3. Classify Severity
 **Calculate total violations:**
 - Conversational filler count
 - Wordy phrases count
 - Redundant phrases count
 - Total = sum of all categories
 **Determine severity:**
 - **Critical:** Total > 10 violations
 - **Warning:** Total 5-10 violations
 - **Pass:** Total < 5 violations
 ### 4. Report Density Findings to Validation Report
 Append to validation report:
 ```markdown
 ## Information Density Validation
 **Anti-Pattern Violations:**
 **Conversational Filler:** {count} occurrences
 [If count > 0, list examples with line numbers]
 **Wordy Phrases:** {count} occurrences
 [If count > 0, list examples with line numbers]
 **Redundant Phrases:** {count} occurrences
 [If count > 0, list examples with line numbers]
 **Total Violations:** {total}
 **Severity Assessment:** [Critical/Warning/Pass]
 **Recommendation:**
 [If Critical] "PRD requires significant revision to improve information density. Every sentence should carry weight without filler."
 [If Warning] "PRD would benefit from reducing wordiness and eliminating filler phrases."
 [If Pass] "PRD demonstrates good information density with minimal violations."
 ```
 ### 5. Display Progress and Auto-Proceed
 Display: "**Information Density Validation Complete**
 Severity: {Critical/Warning/Pass}
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile} (step-v-04-brief-coverage-validation.md)
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - PRD scanned for all three anti-pattern categories
 - Violations counted with line numbers
 - Severity classified correctly
 - Findings reported to validation report
 - Auto-proceeds to next validation step
 - Subprocess attempted with graceful degradation
 ### ❌ SYSTEM FAILURE:
 - Not scanning all anti-pattern categories
 - Missing severity classification
 - Not reporting findings to validation report
 - Pausing for user input (should auto-proceed)
 - Not attempting subprocess architecture
 **Master Rule:** Information density validation runs autonomously. Scan, classify, report, auto-proceed. No user interaction needed.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-04-brief-coverage-validation.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-04-brief-coverage-validation.md
@ -1,214 +0,0 @@
 ---
 name: 'step-v-04-brief-coverage-validation'
 description: 'Product Brief Coverage Check - Validate PRD covers all content from Product Brief (if used as input)'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-05-measurability-validation.md'
 prdFile: '{prd_file_path}'
 productBrief: '{product_brief_path}'
 validationReportPath: '{validation_report_path}'
 ---
 # Step 4: Product Brief Coverage Validation
 ## STEP GOAL:
 Validate that PRD covers all content from Product Brief (if brief was used as input), mapping brief content to PRD sections and identifying gaps.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in systematic validation, not collaborative dialogue
 - ✅ You bring analytical rigor and traceability expertise
 - ✅ This step runs autonomously - no user input needed
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on Product Brief coverage (conditional on brief existence)
 - 🚫 FORBIDDEN to validate other aspects in this step
 - 💬 Approach: Systematic mapping and gap analysis
 - 🚪 This is a validation sequence step - auto-proceeds when complete
 ## EXECUTION PROTOCOLS:
 - 🎯 Check if Product Brief exists in input documents
 - 💬 If no brief: Skip this check and report "N/A - No Product Brief"
 - 🎯 If brief exists: Map brief content to PRD sections
 - 💾 Append coverage findings to validation report
 - 📖 Display "Proceeding to next check..." and load next step
 - 🚫 FORBIDDEN to pause or request user input
 ## CONTEXT BOUNDARIES:
 - Available context: PRD file, input documents from step 1, validation report
 - Focus: Product Brief coverage only (conditional)
 - Limits: Don't validate other aspects, conditional execution
 - Dependencies: Step 1 completed - input documents loaded
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Check for Product Brief
 Check if Product Brief was loaded in step 1's inputDocuments:
 **IF no Product Brief found:**
 Append to validation report:
 ```markdown
 ## Product Brief Coverage
 **Status:** N/A - No Product Brief was provided as input
 ```
 Display: "**Product Brief Coverage: Skipped** (No Product Brief provided)
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile}
 **IF Product Brief exists:** Continue to step 2 below
 ### 2. Attempt Sub-Process Validation
 **Try to use Task tool to spawn a subprocess:**
 "Perform Product Brief coverage validation:
 1. Load the Product Brief
 2. Extract key content:
   - Vision statement
   - Target users/personas
   - Problem statement
   - Key features
   - Goals/objectives
   - Differentiators
   - Constraints
 3. For each item, search PRD for corresponding coverage
 4. Classify coverage: Fully Covered / Partially Covered / Not Found / Intentionally Excluded
 5. Note any gaps with severity: Critical / Moderate / Informational
 Return structured coverage map with classifications."
 ### 3. Graceful Degradation (if Task tool unavailable)
 If Task tool unavailable, perform analysis directly:
 **Extract from Product Brief:**
 - Vision: What is this product?
 - Users: Who is it for?
 - Problem: What problem does it solve?
 - Features: What are the key capabilities?
 - Goals: What are the success criteria?
 - Differentiators: What makes it unique?
 **For each item, search PRD:**
 - Scan Executive Summary for vision
 - Check User Journeys or user personas
 - Look for problem statement
 - Review Functional Requirements for features
 - Check Success Criteria section
 - Search for differentiators
 **Classify coverage:**
 - **Fully Covered:** Content present and complete
 - **Partially Covered:** Content present but incomplete
 - **Not Found:** Content missing from PRD
 - **Intentionally Excluded:** Content explicitly out of scope
 ### 4. Assess Coverage and Severity
 **For each gap (Partially Covered or Not Found):**
 - Is this Critical? (Core vision, primary users, main features)
 - Is this Moderate? (Secondary features, some goals)
 - Is this Informational? (Nice-to-have features, minor details)
 **Note:** Some exclusions may be intentional (valid scoping decisions)
 ### 5. Report Coverage Findings to Validation Report
 Append to validation report:
 ```markdown
 ## Product Brief Coverage
 **Product Brief:** {brief_file_name}
 ### Coverage Map
 **Vision Statement:** [Fully/Partially/Not Found/Intentionally Excluded]
 [If gap: Note severity and specific missing content]
 **Target Users:** [Fully/Partially/Not Found/Intentionally Excluded]
 [If gap: Note severity and specific missing content]
 **Problem Statement:** [Fully/Partially/Not Found/Intentionally Excluded]
 [If gap: Note severity and specific missing content]
 **Key Features:** [Fully/Partially/Not Found/Intentionally Excluded]
 [If gap: List specific features with severity]
 **Goals/Objectives:** [Fully/Partially/Not Found/Intentionally Excluded]
 [If gap: Note severity and specific missing content]
 **Differentiators:** [Fully/Partially/Not Found/Intentionally Excluded]
 [If gap: Note severity and specific missing content]
 ### Coverage Summary
 **Overall Coverage:** [percentage or qualitative assessment]
 **Critical Gaps:** [count] [list if any]
 **Moderate Gaps:** [count] [list if any]
 **Informational Gaps:** [count] [list if any]
 **Recommendation:**
 [If critical gaps exist] "PRD should be revised to cover critical Product Brief content."
 [If moderate gaps] "Consider addressing moderate gaps for complete coverage."
 [If minimal gaps] "PRD provides good coverage of Product Brief content."
 ```
 ### 6. Display Progress and Auto-Proceed
 Display: "**Product Brief Coverage Validation Complete**
 Overall Coverage: {assessment}
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile} (step-v-05-measurability-validation.md)
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - Checked for Product Brief existence correctly
 - If no brief: Reported "N/A" and skipped gracefully
 - If brief exists: Mapped all key brief content to PRD sections
 - Coverage classified appropriately (Fully/Partially/Not Found/Intentionally Excluded)
 - Severity assessed for gaps (Critical/Moderate/Informational)
 - Findings reported to validation report
 - Auto-proceeds to next validation step
 - Subprocess attempted with graceful degradation
 ### ❌ SYSTEM FAILURE:
 - Not checking for brief existence before attempting validation
 - If brief exists: not mapping all key content areas
 - Missing coverage classifications
 - Not reporting findings to validation report
 - Not auto-proceeding
 **Master Rule:** Product Brief coverage is conditional - skip if no brief, validate thoroughly if brief exists. Always auto-proceed.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-05-measurability-validation.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-05-measurability-validation.md
@ -1,228 +0,0 @@
 ---
 name: 'step-v-05-measurability-validation'
 description: 'Measurability Validation - Validate that all requirements (FRs and NFRs) are measurable and testable'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-06-traceability-validation.md'
 prdFile: '{prd_file_path}'
 validationReportPath: '{validation_report_path}'
 ---
 # Step 5: Measurability Validation
 ## STEP GOAL:
 Validate that all Functional Requirements (FRs) and Non-Functional Requirements (NFRs) are measurable, testable, and follow proper format without implementation details.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in systematic validation, not collaborative dialogue
 - ✅ You bring analytical rigor and requirements engineering expertise
 - ✅ This step runs autonomously - no user input needed
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on FR and NFR measurability
 - 🚫 FORBIDDEN to validate other aspects in this step
 - 💬 Approach: Systematic requirement-by-requirement analysis
 - 🚪 This is a validation sequence step - auto-proceeds when complete
 ## EXECUTION PROTOCOLS:
 - 🎯 Extract all FRs and NFRs from PRD
 - 💾 Validate each for measurability and format
 - 📖 Append findings to validation report
 - 📖 Display "Proceeding to next check..." and load next step
 - 🚫 FORBIDDEN to pause or request user input
 ## CONTEXT BOUNDARIES:
 - Available context: PRD file, validation report
 - Focus: FR and NFR measurability only
 - Limits: Don't validate other aspects, don't pause for user input
 - Dependencies: Steps 2-4 completed - initial validation checks done
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Attempt Sub-Process Validation
 **Try to use Task tool to spawn a subprocess:**
 "Perform measurability validation on this PRD:
 **Functional Requirements (FRs):**
 1. Extract all FRs from Functional Requirements section
 2. Check each FR for:
   - '[Actor] can [capability]' format compliance
   - No subjective adjectives (easy, fast, simple, intuitive, etc.)
   - No vague quantifiers (multiple, several, some, many, etc.)
   - No implementation details (technology names, library names, data structures unless capability-relevant)
 3. Document violations with line numbers
 **Non-Functional Requirements (NFRs):**
 1. Extract all NFRs from Non-Functional Requirements section
 2. Check each NFR for:
   - Specific metrics with measurement methods
   - Template compliance (criterion, metric, measurement method, context)
   - Context included (why this matters, who it affects)
 3. Document violations with line numbers
 Return structured findings with violation counts and examples."
 ### 2. Graceful Degradation (if Task tool unavailable)
 If Task tool unavailable, perform analysis directly:
 **Functional Requirements Analysis:**
 Extract all FRs and check each for:
 **Format compliance:**
 - Does it follow "[Actor] can [capability]" pattern?
 - Is actor clearly defined?
 - Is capability actionable and testable?
 **No subjective adjectives:**
 - Scan for: easy, fast, simple, intuitive, user-friendly, responsive, quick, efficient (without metrics)
 - Note line numbers
 **No vague quantifiers:**
 - Scan for: multiple, several, some, many, few, various, number of
 - Note line numbers
 **No implementation details:**
 - Scan for: React, Vue, Angular, PostgreSQL, MongoDB, AWS, Docker, Kubernetes, Redux, etc.
 - Unless capability-relevant (e.g., "API consumers can access...")
 - Note line numbers
 **Non-Functional Requirements Analysis:**
 Extract all NFRs and check each for:
 **Specific metrics:**
 - Is there a measurable criterion? (e.g., "response time < 200ms", not "fast response")
 - Can this be measured or tested?
 **Template compliance:**
 - Criterion defined?
 - Metric specified?
 - Measurement method included?
 - Context provided?
 ### 3. Tally Violations
 **FR Violations:**
 - Format violations: count
 - Subjective adjectives: count
 - Vague quantifiers: count
 - Implementation leakage: count
 - Total FR violations: sum
 **NFR Violations:**
 - Missing metrics: count
 - Incomplete template: count
 - Missing context: count
 - Total NFR violations: sum
 **Total violations:** FR violations + NFR violations
 ### 4. Report Measurability Findings to Validation Report
 Append to validation report:
 ```markdown
 ## Measurability Validation
 ### Functional Requirements
 **Total FRs Analyzed:** {count}
 **Format Violations:** {count}
 [If violations exist, list examples with line numbers]
 **Subjective Adjectives Found:** {count}
 [If found, list examples with line numbers]
 **Vague Quantifiers Found:** {count}
 [If found, list examples with line numbers]
 **Implementation Leakage:** {count}
 [If found, list examples with line numbers]
 **FR Violations Total:** {total}
 ### Non-Functional Requirements
 **Total NFRs Analyzed:** {count}
 **Missing Metrics:** {count}
 [If missing, list examples with line numbers]
 **Incomplete Template:** {count}
 [If incomplete, list examples with line numbers]
 **Missing Context:** {count}
 [If missing, list examples with line numbers]
 **NFR Violations Total:** {total}
 ### Overall Assessment
 **Total Requirements:** {FRs + NFRs}
 **Total Violations:** {FR violations + NFR violations}
 **Severity:** [Critical if >10 violations, Warning if 5-10, Pass if <5]
 **Recommendation:**
 [If Critical] "Many requirements are not measurable or testable. Requirements must be revised to be testable for downstream work."
 [If Warning] "Some requirements need refinement for measurability. Focus on violating requirements above."
 [If Pass] "Requirements demonstrate good measurability with minimal issues."
 ```
 ### 5. Display Progress and Auto-Proceed
 Display: "**Measurability Validation Complete**
 Total Violations: {count} ({severity})
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile} (step-v-06-traceability-validation.md)
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - All FRs extracted and analyzed for measurability
 - All NFRs extracted and analyzed for measurability
 - Violations documented with line numbers
 - Severity assessed correctly
 - Findings reported to validation report
 - Auto-proceeds to next validation step
 - Subprocess attempted with graceful degradation
 ### ❌ SYSTEM FAILURE:
 - Not analyzing all FRs and NFRs
 - Missing line numbers for violations
 - Not reporting findings to validation report
 - Not assessing severity
 - Not auto-proceeding
 **Master Rule:** Requirements must be testable to be useful. Validate every requirement for measurability, document violations, auto-proceed.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-06-traceability-validation.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-06-traceability-validation.md
@ -1,217 +0,0 @@
 ---
 name: 'step-v-06-traceability-validation'
 description: 'Traceability Validation - Validate the traceability chain from vision → success → journeys → FRs is intact'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-07-implementation-leakage-validation.md'
 prdFile: '{prd_file_path}'
 validationReportPath: '{validation_report_path}'
 ---
 # Step 6: Traceability Validation
 ## STEP GOAL:
 Validate the traceability chain from Executive Summary → Success Criteria → User Journeys → Functional Requirements is intact, ensuring every requirement traces back to a user need or business objective.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in systematic validation, not collaborative dialogue
 - ✅ You bring analytical rigor and traceability matrix expertise
 - ✅ This step runs autonomously - no user input needed
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on traceability chain validation
 - 🚫 FORBIDDEN to validate other aspects in this step
 - 💬 Approach: Systematic chain validation and orphan detection
 - 🚪 This is a validation sequence step - auto-proceeds when complete
 ## EXECUTION PROTOCOLS:
 - 🎯 Build and validate traceability matrix
 - 💾 Identify broken chains and orphan requirements
 - 📖 Append findings to validation report
 - 📖 Display "Proceeding to next check..." and load next step
 - 🚫 FORBIDDEN to pause or request user input
 ## CONTEXT BOUNDARIES:
 - Available context: PRD file, validation report
 - Focus: Traceability chain validation only
 - Limits: Don't validate other aspects, don't pause for user input
 - Dependencies: Steps 2-5 completed - initial validations done
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Attempt Sub-Process Validation
 **Try to use Task tool to spawn a subprocess:**
 "Perform traceability validation on this PRD:
 1. Extract content from Executive Summary (vision, goals)
 2. Extract Success Criteria
 3. Extract User Journeys (user types, flows, outcomes)
 4. Extract Functional Requirements (FRs)
 5. Extract Product Scope (in-scope items)
 **Validate chains:**
 - Executive Summary → Success Criteria: Does vision align with defined success?
 - Success Criteria → User Journeys: Are success criteria supported by user journeys?
 - User Journeys → Functional Requirements: Does each FR trace back to a user journey?
 - Scope → FRs: Do MVP scope FRs align with in-scope items?
 **Identify orphans:**
 - FRs not traceable to any user journey or business objective
 - Success criteria not supported by user journeys
 - User journeys without supporting FRs
 Build traceability matrix and identify broken chains and orphan FRs.
 Return structured findings with chain status and orphan list."
 ### 2. Graceful Degradation (if Task tool unavailable)
 If Task tool unavailable, perform analysis directly:
 **Step 1: Extract key elements**
 - Executive Summary: Note vision, goals, objectives
 - Success Criteria: List all criteria
 - User Journeys: List user types and their flows
 - Functional Requirements: List all FRs
 - Product Scope: List in-scope items
 **Step 2: Validate Executive Summary → Success Criteria**
 - Does Executive Summary mention the success dimensions?
 - Are Success Criteria aligned with vision?
 - Note any misalignment
 **Step 3: Validate Success Criteria → User Journeys**
 - For each success criterion, is there a user journey that achieves it?
 - Note success criteria without supporting journeys
 **Step 4: Validate User Journeys → FRs**
 - For each user journey/flow, are there FRs that enable it?
 - List FRs with no clear user journey origin
 - Note orphan FRs (requirements without traceable source)
 **Step 5: Validate Scope → FR Alignment**
 - Does MVP scope align with essential FRs?
 - Are in-scope items supported by FRs?
 - Note misalignments
 **Step 6: Build traceability matrix**
 - Map each FR to its source (journey or business objective)
 - Note orphan FRs
 - Identify broken chains
 ### 3. Tally Traceability Issues
 **Broken chains:**
 - Executive Summary → Success Criteria gaps: count
 - Success Criteria → User Journeys gaps: count
 - User Journeys → FRs gaps: count
 - Scope → FR misalignments: count
 **Orphan elements:**
 - Orphan FRs (no traceable source): count
 - Unsupported success criteria: count
 - User journeys without FRs: count
 **Total issues:** Sum of all broken chains and orphans
 ### 4. Report Traceability Findings to Validation Report
 Append to validation report:
 ```markdown
 ## Traceability Validation
 ### Chain Validation
 **Executive Summary → Success Criteria:** [Intact/Gaps Identified]
 {If gaps: List specific misalignments}
 **Success Criteria → User Journeys:** [Intact/Gaps Identified]
 {If gaps: List unsupported success criteria}
 **User Journeys → Functional Requirements:** [Intact/Gaps Identified]
 {If gaps: List journeys without supporting FRs}
 **Scope → FR Alignment:** [Intact/Misaligned]
 {If misaligned: List specific issues}
 ### Orphan Elements
 **Orphan Functional Requirements:** {count}
 {List orphan FRs with numbers}
 **Unsupported Success Criteria:** {count}
 {List unsupported criteria}
 **User Journeys Without FRs:** {count}
 {List journeys without FRs}
 ### Traceability Matrix
 {Summary table showing traceability coverage}
 **Total Traceability Issues:** {total}
 **Severity:** [Critical if orphan FRs exist, Warning if gaps, Pass if intact]
 **Recommendation:**
 [If Critical] "Orphan requirements exist - every FR must trace back to a user need or business objective."
 [If Warning] "Traceability gaps identified - strengthen chains to ensure all requirements are justified."
 [If Pass] "Traceability chain is intact - all requirements trace to user needs or business objectives."
 ```
 ### 5. Display Progress and Auto-Proceed
 Display: "**Traceability Validation Complete**
 Total Issues: {count} ({severity})
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile} (step-v-07-implementation-leakage-validation.md)
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - All traceability chains validated systematically
 - Orphan FRs identified with numbers
 - Broken chains documented
 - Traceability matrix built
 - Severity assessed correctly
 - Findings reported to validation report
 - Auto-proceeds to next validation step
 - Subprocess attempted with graceful degradation
 ### ❌ SYSTEM FAILURE:
 - Not validating all traceability chains
 - Missing orphan FR detection
 - Not building traceability matrix
 - Not reporting findings to validation report
 - Not auto-proceeding
 **Master Rule:** Every requirement should trace to a user need or business objective. Orphan FRs indicate broken traceability that must be fixed.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-07-implementation-leakage-validation.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-07-implementation-leakage-validation.md
@ -1,205 +0,0 @@
 ---
 name: 'step-v-07-implementation-leakage-validation'
 description: 'Implementation Leakage Check - Ensure FRs and NFRs don\'t include implementation details'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-08-domain-compliance-validation.md'
 prdFile: '{prd_file_path}'
 validationReportPath: '{validation_report_path}'
 ---
 # Step 7: Implementation Leakage Validation
 ## STEP GOAL:
 Ensure Functional Requirements and Non-Functional Requirements don't include implementation details - they should specify WHAT, not HOW.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in systematic validation, not collaborative dialogue
 - ✅ You bring analytical rigor and separation of concerns expertise
 - ✅ This step runs autonomously - no user input needed
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on implementation leakage detection
 - 🚫 FORBIDDEN to validate other aspects in this step
 - 💬 Approach: Systematic scanning for technology and implementation terms
 - 🚪 This is a validation sequence step - auto-proceeds when complete
 ## EXECUTION PROTOCOLS:
 - 🎯 Scan FRs and NFRs for implementation terms
 - 💾 Distinguish capability-relevant vs leakage
 - 📖 Append findings to validation report
 - 📖 Display "Proceeding to next check..." and load next step
 - 🚫 FORBIDDEN to pause or request user input
 ## CONTEXT BOUNDARIES:
 - Available context: PRD file, validation report
 - Focus: Implementation leakage detection only
 - Limits: Don't validate other aspects, don't pause for user input
 - Dependencies: Steps 2-6 completed - initial validations done
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Attempt Sub-Process Validation
 **Try to use Task tool to spawn a subprocess:**
 "Perform implementation leakage validation on this PRD:
 **Scan for:**
 1. Technology names (React, Vue, Angular, PostgreSQL, MongoDB, AWS, GCP, Azure, Docker, Kubernetes, etc.)
 2. Library names (Redux, axios, lodash, Express, Django, Rails, Spring, etc.)
 3. Data structures (JSON, XML, CSV) unless relevant to capability
 4. Architecture patterns (MVC, microservices, serverless) unless business requirement
 5. Protocol names (HTTP, REST, GraphQL, WebSockets) - check if capability-relevant
 **For each term found:**
 - Is this capability-relevant? (e.g., 'API consumers can access...' - API is capability)
 - Or is this implementation detail? (e.g., 'React component for...' - implementation)
 Document violations with line numbers and explanation.
 Return structured findings with leakage counts and examples."
 ### 2. Graceful Degradation (if Task tool unavailable)
 If Task tool unavailable, perform analysis directly:
 **Implementation leakage terms to scan for:**
 **Frontend Frameworks:**
 React, Vue, Angular, Svelte, Solid, Next.js, Nuxt, etc.
 **Backend Frameworks:**
 Express, Django, Rails, Spring, Laravel, FastAPI, etc.
 **Databases:**
 PostgreSQL, MySQL, MongoDB, Redis, DynamoDB, Cassandra, etc.
 **Cloud Platforms:**
 AWS, GCP, Azure, Cloudflare, Vercel, Netlify, etc.
 **Infrastructure:**
 Docker, Kubernetes, Terraform, Ansible, etc.
 **Libraries:**
 Redux, Zustand, axios, fetch, lodash, jQuery, etc.
 **Data Formats:**
 JSON, XML, YAML, CSV (unless capability-relevant)
 **For each term found in FRs/NFRs:**
 - Determine if it's capability-relevant or implementation leakage
 - Example: "API consumers can access data via REST endpoints" - API/REST is capability
 - Example: "React components fetch data using Redux" - implementation leakage
 **Count violations and note line numbers**
 ### 3. Tally Implementation Leakage
 **By category:**
 - Frontend framework leakage: count
 - Backend framework leakage: count
 - Database leakage: count
 - Cloud platform leakage: count
 - Infrastructure leakage: count
 - Library leakage: count
 - Other implementation details: count
 **Total implementation leakage violations:** sum
 ### 4. Report Implementation Leakage Findings to Validation Report
 Append to validation report:
 ```markdown
 ## Implementation Leakage Validation
 ### Leakage by Category
 **Frontend Frameworks:** {count} violations
 {If violations, list examples with line numbers}
 **Backend Frameworks:** {count} violations
 {If violations, list examples with line numbers}
 **Databases:** {count} violations
 {If violations, list examples with line numbers}
 **Cloud Platforms:** {count} violations
 {If violations, list examples with line numbers}
 **Infrastructure:** {count} violations
 {If violations, list examples with line numbers}
 **Libraries:** {count} violations
 {If violations, list examples with line numbers}
 **Other Implementation Details:** {count} violations
 {If violations, list examples with line numbers}
 ### Summary
 **Total Implementation Leakage Violations:** {total}
 **Severity:** [Critical if >5 violations, Warning if 2-5, Pass if <2]
 **Recommendation:**
 [If Critical] "Extensive implementation leakage found. Requirements specify HOW instead of WHAT. Remove all implementation details - these belong in architecture, not PRD."
 [If Warning] "Some implementation leakage detected. Review violations and remove implementation details from requirements."
 [If Pass] "No significant implementation leakage found. Requirements properly specify WHAT without HOW."
 **Note:** API consumers, GraphQL (when required), and other capability-relevant terms are acceptable when they describe WHAT the system must do, not HOW to build it.
 ```
 ### 5. Display Progress and Auto-Proceed
 Display: "**Implementation Leakage Validation Complete**
 Total Violations: {count} ({severity})
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile} (step-v-08-domain-compliance-validation.md)
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - Scanned FRs and NFRs for all implementation term categories
 - Distinguished capability-relevant from implementation leakage
 - Violations documented with line numbers and explanations
 - Severity assessed correctly
 - Findings reported to validation report
 - Auto-proceeds to next validation step
 - Subprocess attempted with graceful degradation
 ### ❌ SYSTEM FAILURE:
 - Not scanning all implementation term categories
 - Not distinguishing capability-relevant from leakage
 - Missing line numbers for violations
 - Not reporting findings to validation report
 - Not auto-proceeding
 **Master Rule:** Requirements specify WHAT, not HOW. Implementation details belong in architecture documents, not PRDs.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-08-domain-compliance-validation.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-08-domain-compliance-validation.md
@ -1,243 +0,0 @@
 ---
 name: 'step-v-08-domain-compliance-validation'
 description: 'Domain Compliance Validation - Validate domain-specific requirements are present for high-complexity domains'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-09-project-type-validation.md'
 prdFile: '{prd_file_path}'
 prdFrontmatter: '{prd_frontmatter}'
 validationReportPath: '{validation_report_path}'
 domainComplexityData: '../data/domain-complexity.csv'
 ---
 # Step 8: Domain Compliance Validation
 ## STEP GOAL:
 Validate domain-specific requirements are present for high-complexity domains (Healthcare, Fintech, GovTech, etc.), ensuring regulatory and compliance requirements are properly documented.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in systematic validation, not collaborative dialogue
 - ✅ You bring domain expertise and compliance knowledge
 - ✅ This step runs autonomously - no user input needed
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on domain-specific compliance requirements
 - 🚫 FORBIDDEN to validate other aspects in this step
 - 💬 Approach: Conditional validation based on domain classification
 - 🚪 This is a validation sequence step - auto-proceeds when complete
 ## EXECUTION PROTOCOLS:
 - 🎯 Check classification.domain from PRD frontmatter
 - 💬 If low complexity (general): Skip detailed checks
 - 🎯 If high complexity: Validate required special sections
 - 💾 Append compliance findings to validation report
 - 📖 Display "Proceeding to next check..." and load next step
 - 🚫 FORBIDDEN to pause or request user input
 ## CONTEXT BOUNDARIES:
 - Available context: PRD file with frontmatter classification, validation report
 - Focus: Domain compliance only (conditional on domain complexity)
 - Limits: Don't validate other aspects, conditional execution
 - Dependencies: Steps 2-7 completed - format and requirements validation done
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Load Domain Complexity Data
 Load and read the complete file at:
 `{domainComplexityData}` (../data/domain-complexity.csv)
 This CSV contains:
 - Domain classifications and complexity levels (high/medium/low)
 - Required special sections for each domain
 - Key concerns and requirements for regulated industries
 Internalize this data - it drives which domains require special compliance sections.
 ### 2. Extract Domain Classification
 From PRD frontmatter, extract:
 - `classification.domain` - what domain is this PRD for?
 **If no domain classification found:**
 Treat as "general" (low complexity) and proceed to step 4
 ### 2. Determine Domain Complexity
 **Low complexity domains (skip detailed checks):**
 - General
 - Consumer apps (standard e-commerce, social, productivity)
 - Content websites
 - Business tools (standard)
 **High complexity domains (require special sections):**
 - Healthcare / Healthtech
 - Fintech / Financial services
 - GovTech / Public sector
 - EdTech (educational records, accredited courses)
 - Legal tech
 - Other regulated domains
 ### 3. For High-Complexity Domains: Validate Required Special Sections
 **Attempt subprocess validation:**
 "Perform domain compliance validation for {domain}:
 Based on {domain} requirements, check PRD for:
 **Healthcare:**
 - Clinical Requirements section
 - Regulatory Pathway (FDA, HIPAA, etc.)
 - Safety Measures
 - HIPAA Compliance (data privacy, security)
 - Patient safety considerations
 **Fintech:**
 - Compliance Matrix (SOC2, PCI-DSS, GDPR, etc.)
 - Security Architecture
 - Audit Requirements
 - Fraud Prevention measures
 - Financial transaction handling
 **GovTech:**
 - Accessibility Standards (WCAG 2.1 AA, Section 508)
 - Procurement Compliance
 - Security Clearance requirements
 - Data residency requirements
 **Other regulated domains:**
 - Check for domain-specific regulatory sections
 - Compliance requirements
 - Special considerations
 For each required section:
 - Is it present in PRD?
 - Is it adequately documented?
 - Note any gaps
 Return compliance matrix with presence/adequacy assessment."
 **Graceful degradation (if no Task tool):**
 - Manually check for required sections based on domain
 - List present sections and missing sections
 - Assess adequacy of documentation
 ### 5. For Low-Complexity Domains: Skip Detailed Checks
 Append to validation report:
 ```markdown
 ## Domain Compliance Validation
 **Domain:** {domain}
 **Complexity:** Low (general/standard)
 **Assessment:** N/A - No special domain compliance requirements
 **Note:** This PRD is for a standard domain without regulatory compliance requirements.
 ```
 Display: "**Domain Compliance Validation Skipped**
 Domain: {domain} (low complexity)
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile}
 ### 6. Report Compliance Findings (High-Complexity Domains)
 Append to validation report:
 ```markdown
 ## Domain Compliance Validation
 **Domain:** {domain}
 **Complexity:** High (regulated)
 ### Required Special Sections
 **{Section 1 Name}:** [Present/Missing/Adequate]
 {If missing or inadequate: Note specific gaps}
 **{Section 2 Name}:** [Present/Missing/Adequate]
 {If missing or inadequate: Note specific gaps}
 [Continue for all required sections]
 ### Compliance Matrix
 | Requirement | Status | Notes |
 |-------------|--------|-------|
 | {Requirement 1} | [Met/Partial/Missing] | {Notes} |
 | {Requirement 2} | [Met/Partial/Missing] | {Notes} |
 [... continue for all requirements]
 ### Summary
 **Required Sections Present:** {count}/{total}
 **Compliance Gaps:** {count}
 **Severity:** [Critical if missing regulatory sections, Warning if incomplete, Pass if complete]
 **Recommendation:**
 [If Critical] "PRD is missing required domain-specific compliance sections. These are essential for {domain} products."
 [If Warning] "Some domain compliance sections are incomplete. Strengthen documentation for full compliance."
 [If Pass] "All required domain compliance sections are present and adequately documented."
 ```
 ### 7. Display Progress and Auto-Proceed
 Display: "**Domain Compliance Validation Complete**
 Domain: {domain} ({complexity})
 Compliance Status: {status}
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile} (step-v-09-project-type-validation.md)
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - Domain classification extracted correctly
 - Complexity assessed appropriately
 - Low complexity domains: Skipped with clear "N/A" documentation
 - High complexity domains: All required sections checked
 - Compliance matrix built with status for each requirement
 - Severity assessed correctly
 - Findings reported to validation report
 - Auto-proceeds to next validation step
 - Subprocess attempted with graceful degradation
 ### ❌ SYSTEM FAILURE:
 - Not checking domain classification before proceeding
 - Performing detailed checks on low complexity domains
 - For high complexity: missing required section checks
 - Not building compliance matrix
 - Not reporting findings to validation report
 - Not auto-proceeding
 **Master Rule:** Domain compliance is conditional. High-complexity domains require special sections - low complexity domains skip these checks.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-09-project-type-validation.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-09-project-type-validation.md
@ -1,263 +0,0 @@
 ---
 name: 'step-v-09-project-type-validation'
 description: 'Project-Type Compliance Validation - Validate project-type specific requirements are properly documented'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-10-smart-validation.md'
 prdFile: '{prd_file_path}'
 prdFrontmatter: '{prd_frontmatter}'
 validationReportPath: '{validation_report_path}'
 projectTypesData: '../data/project-types.csv'
 ---
 # Step 9: Project-Type Compliance Validation
 ## STEP GOAL:
 Validate project-type specific requirements are properly documented - different project types (api_backend, web_app, mobile_app, etc.) have different required and excluded sections.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in systematic validation, not collaborative dialogue
 - ✅ You bring project type expertise and architectural knowledge
 - ✅ This step runs autonomously - no user input needed
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on project-type compliance
 - 🚫 FORBIDDEN to validate other aspects in this step
 - 💬 Approach: Validate required sections present, excluded sections absent
 - 🚪 This is a validation sequence step - auto-proceeds when complete
 ## EXECUTION PROTOCOLS:
 - 🎯 Check classification.projectType from PRD frontmatter
 - 🎯 Validate required sections for that project type are present
 - 🎯 Validate excluded sections for that project type are absent
 - 💾 Append compliance findings to validation report
 - 📖 Display "Proceeding to next check..." and load next step
 - 🚫 FORBIDDEN to pause or request user input
 ## CONTEXT BOUNDARIES:
 - Available context: PRD file with frontmatter classification, validation report
 - Focus: Project-type compliance only
 - Limits: Don't validate other aspects, don't pause for user input
 - Dependencies: Steps 2-8 completed - domain and requirements validation done
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Load Project Types Data
 Load and read the complete file at:
 `{projectTypesData}` (../data/project-types.csv)
 This CSV contains:
 - Detection signals for each project type
 - Required sections for each project type
 - Skip/excluded sections for each project type
 - Innovation signals
 Internalize this data - it drives what sections must be present or absent for each project type.
 ### 2. Extract Project Type Classification
 From PRD frontmatter, extract:
 - `classification.projectType` - what type of project is this?
 **Common project types:**
 - api_backend
 - web_app
 - mobile_app
 - desktop_app
 - data_pipeline
 - ml_system
 - library_sdk
 - infrastructure
 - other
 **If no projectType classification found:**
 Assume "web_app" (most common) and note in findings
 ### 3. Determine Required and Excluded Sections from CSV Data
 **From loaded project-types.csv data, for this project type:**
 **Required sections:** (from required_sections column)
 These MUST be present in the PRD
 **Skip sections:** (from skip_sections column)
 These MUST NOT be present in the PRD
 **Example mappings from CSV:**
 - api_backend: Required=[endpoint_specs, auth_model, data_schemas], Skip=[ux_ui, visual_design]
 - mobile_app: Required=[platform_reqs, device_permissions, offline_mode], Skip=[desktop_features, cli_commands]
 - cli_tool: Required=[command_structure, output_formats, config_schema], Skip=[visual_design, ux_principles, touch_interactions]
 - etc.
 ### 4. Validate Against CSV-Based Requirements
 **Based on project type, determine:**
 **api_backend:**
 - Required: Endpoint Specs, Auth Model, Data Schemas, API Versioning
 - Excluded: UX/UI sections, mobile-specific sections
 **web_app:**
 - Required: User Journeys, UX/UI Requirements, Responsive Design
 - Excluded: None typically
 **mobile_app:**
 - Required: Mobile UX, Platform specifics (iOS/Android), Offline mode
 - Excluded: Desktop-specific sections
 **desktop_app:**
 - Required: Desktop UX, Platform specifics (Windows/Mac/Linux)
 - Excluded: Mobile-specific sections
 **data_pipeline:**
 - Required: Data Sources, Data Transformation, Data Sinks, Error Handling
 - Excluded: UX/UI sections
 **ml_system:**
 - Required: Model Requirements, Training Data, Inference Requirements, Model Performance
 - Excluded: UX/UI sections (unless ML UI)
 **library_sdk:**
 - Required: API Surface, Usage Examples, Integration Guide
 - Excluded: UX/UI sections, deployment sections
 **infrastructure:**
 - Required: Infrastructure Components, Deployment, Monitoring, Scaling
 - Excluded: Feature requirements (this is infrastructure, not product)
 ### 4. Attempt Sub-Process Validation
 "Perform project-type compliance validation for {projectType}:
 **Check that required sections are present:**
 {List required sections for this project type}
 For each: Is it present in PRD? Is it adequately documented?
 **Check that excluded sections are absent:**
 {List excluded sections for this project type}
 For each: Is it absent from PRD? (Should not be present)
 Build compliance table showing:
 - Required sections: [Present/Missing/Incomplete]
 - Excluded sections: [Absent/Present] (Present = violation)
 Return compliance table with findings."
 **Graceful degradation (if no Task tool):**
 - Manually check PRD for required sections
 - Manually check PRD for excluded sections
 - Build compliance table
 ### 5. Build Compliance Table
 **Required sections check:**
 - For each required section: Present / Missing / Incomplete
 - Count: Required sections present vs total required
 **Excluded sections check:**
 - For each excluded section: Absent / Present (violation)
 - Count: Excluded sections present (violations)
 **Total compliance score:**
 - Required: {present}/{total}
 - Excluded violations: {count}
 ### 6. Report Project-Type Compliance Findings to Validation Report
 Append to validation report:
 ```markdown
 ## Project-Type Compliance Validation
 **Project Type:** {projectType}
 ### Required Sections
 **{Section 1}:** [Present/Missing/Incomplete]
 {If missing or incomplete: Note specific gaps}
 **{Section 2}:** [Present/Missing/Incomplete]
 {If missing or incomplete: Note specific gaps}
 [Continue for all required sections]
 ### Excluded Sections (Should Not Be Present)
 **{Section 1}:** [Absent/Present] ✓
 {If present: This section should not be present for {projectType}}
 **{Section 2}:** [Absent/Present] ✓
 {If present: This section should not be present for {projectType}}
 [Continue for all excluded sections]
 ### Compliance Summary
 **Required Sections:** {present}/{total} present
 **Excluded Sections Present:** {violations} (should be 0)
 **Compliance Score:** {percentage}%
 **Severity:** [Critical if required sections missing, Warning if incomplete, Pass if complete]
 **Recommendation:**
 [If Critical] "PRD is missing required sections for {projectType}. Add missing sections to properly specify this type of project."
 [If Warning] "Some required sections for {projectType} are incomplete. Strengthen documentation."
 [If Pass] "All required sections for {projectType} are present. No excluded sections found."
 ```
 ### 7. Display Progress and Auto-Proceed
 Display: "**Project-Type Compliance Validation Complete**
 Project Type: {projectType}
 Compliance: {score}%
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile} (step-v-10-smart-validation.md)
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - Project type extracted correctly (or default assumed)
 - Required sections validated for presence and completeness
 - Excluded sections validated for absence
 - Compliance table built with status for all sections
 - Severity assessed correctly
 - Findings reported to validation report
 - Auto-proceeds to next validation step
 - Subprocess attempted with graceful degradation
 ### ❌ SYSTEM FAILURE:
 - Not checking project type before proceeding
 - Missing required section checks
 - Missing excluded section checks
 - Not building compliance table
 - Not reporting findings to validation report
 - Not auto-proceeding
 **Master Rule:** Different project types have different requirements. API PRDs don't need UX sections - validate accordingly.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-10-smart-validation.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-10-smart-validation.md
@ -1,209 +0,0 @@
 ---
 name: 'step-v-10-smart-validation'
 description: 'SMART Requirements Validation - Validate Functional Requirements meet SMART quality criteria'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-11-holistic-quality-validation.md'
 prdFile: '{prd_file_path}'
 validationReportPath: '{validation_report_path}'
 ---
 # Step 10: SMART Requirements Validation
 ## STEP GOAL:
 Validate Functional Requirements meet SMART quality criteria (Specific, Measurable, Attainable, Relevant, Traceable), ensuring high-quality requirements.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 - ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in systematic validation, not collaborative dialogue
 - ✅ You bring requirements engineering expertise and quality assessment
 - ✅ This step runs autonomously - no user input needed
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on FR quality assessment using SMART framework
 - 🚫 FORBIDDEN to validate other aspects in this step
 - 💬 Approach: Score each FR on SMART criteria (1-5 scale)
 - 🚪 This is a validation sequence step - auto-proceeds when complete
 ## EXECUTION PROTOCOLS:
 - 🎯 Extract all FRs from PRD
 - 🎯 Score each FR on SMART criteria (Specific, Measurable, Attainable, Relevant, Traceable)
 - 💾 Flag FRs with score < 3 in any category
 - 📖 Append scoring table and suggestions to validation report
 - 📖 Display "Proceeding to next check..." and load next step
 - 🚫 FORBIDDEN to pause or request user input
 ## CONTEXT BOUNDARIES:
 - Available context: PRD file, validation report
 - Focus: FR quality assessment only using SMART framework
 - Limits: Don't validate NFRs or other aspects, don't pause for user input
 - Dependencies: Steps 2-9 completed - comprehensive validation checks done
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Extract All Functional Requirements
 From the PRD's Functional Requirements section, extract:
 - All FRs with their FR numbers (FR-001, FR-002, etc.)
 - Count total FRs
 ### 2. Attempt Sub-Process Validation
 **Try to use Task tool to spawn a subprocess:**
 "Perform SMART requirements validation on these Functional Requirements:
 {List all FRs}
 **For each FR, score on SMART criteria (1-5 scale):**
 **Specific (1-5):**
 - 5: Clear, unambiguous, well-defined
 - 3: Somewhat clear but could be more specific
 - 1: Vague, ambiguous, unclear
 **Measurable (1-5):**
 - 5: Quantifiable metrics, testable
 - 3: Partially measurable
 - 1: Not measurable, subjective
 **Attainable (1-5):**
 - 5: Realistic, achievable with constraints
 - 3: Probably achievable but uncertain
 - 1: Unrealistic, technically infeasible
 **Relevant (1-5):**
 - 5: Clearly aligned with user needs and business objectives
 - 3: Somewhat relevant but connection unclear
 - 1: Not relevant, doesn't align with goals
 **Traceable (1-5):**
 - 5: Clearly traces to user journey or business objective
 - 3: Partially traceable
 - 1: Orphan requirement, no clear source
 **For each FR with score < 3 in any category:**
 - Provide specific improvement suggestions
 Return scoring table with all FR scores and improvement suggestions for low-scoring FRs."
 **Graceful degradation (if no Task tool):**
 - Manually score each FR on SMART criteria
 - Note FRs with low scores
 - Provide improvement suggestions
 ### 3. Build Scoring Table
 For each FR:
 - FR number
 - Specific score (1-5)
 - Measurable score (1-5)
 - Attainable score (1-5)
 - Relevant score (1-5)
 - Traceable score (1-5)
 - Average score
 - Flag if any category < 3
 **Calculate overall FR quality:**
 - Percentage of FRs with all scores ≥ 3
 - Percentage of FRs with all scores ≥ 4
 - Average score across all FRs and categories
 ### 4. Report SMART Findings to Validation Report
 Append to validation report:
 ```markdown
 ## SMART Requirements Validation
 **Total Functional Requirements:** {count}
 ### Scoring Summary
 **All scores ≥ 3:** {percentage}% ({count}/{total})
 **All scores ≥ 4:** {percentage}% ({count}/{total})
 **Overall Average Score:** {average}/5.0
 ### Scoring Table
 | FR # | Specific | Measurable | Attainable | Relevant | Traceable | Average | Flag |
 |------|----------|------------|------------|----------|-----------|--------|------|
 | FR-001 | {s1} | {m1} | {a1} | {r1} | {t1} | {avg1} | {X if any <3} |
 | FR-002 | {s2} | {m2} | {a2} | {r2} | {t2} | {avg2} | {X if any <3} |
 [Continue for all FRs]
 **Legend:** 1=Poor, 3=Acceptable, 5=Excellent
 **Flag:** X = Score < 3 in one or more categories
 ### Improvement Suggestions
 **Low-Scoring FRs:**
 **FR-{number}:** {specific suggestion for improvement}
 [For each FR with score < 3 in any category]
 ### Overall Assessment
 **Severity:** [Critical if >30% flagged FRs, Warning if 10-30%, Pass if <10%]
 **Recommendation:**
 [If Critical] "Many FRs have quality issues. Revise flagged FRs using SMART framework to improve clarity and testability."
 [If Warning] "Some FRs would benefit from SMART refinement. Focus on flagged requirements above."
 [If Pass] "Functional Requirements demonstrate good SMART quality overall."
 ```
 ### 5. Display Progress and Auto-Proceed
 Display: "**SMART Requirements Validation Complete**
 FR Quality: {percentage}% with acceptable scores ({severity})
 **Proceeding to next validation check...**"
 Without delay, read fully and follow: {nextStepFile} (step-v-11-holistic-quality-validation.md)
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - All FRs extracted from PRD
 - Each FR scored on all 5 SMART criteria (1-5 scale)
 - FRs with scores < 3 flagged for improvement
 - Improvement suggestions provided for low-scoring FRs
 - Scoring table built with all FR scores
 - Overall quality assessment calculated
 - Findings reported to validation report
 - Auto-proceeds to next validation step
 - Subprocess attempted with graceful degradation
 ### ❌ SYSTEM FAILURE:
 - Not scoring all FRs on all SMART criteria
 - Missing improvement suggestions for low-scoring FRs
 - Not building scoring table
 - Not calculating overall quality metrics
 - Not reporting findings to validation report
 - Not auto-proceeding
 **Master Rule:** FRs should be high-quality, not just present. SMART framework provides objective quality measure.
--- a/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-11-holistic-quality-validation.md
+++ b/src/bmm-skills/2-plan-workflows/create-prd/steps-v/step-v-11-holistic-quality-validation.md
@ -1,264 +0,0 @@
 ---
 name: 'step-v-11-holistic-quality-validation'
 description: 'Holistic Quality Assessment - Assess PRD as cohesive, compelling document - is it a good PRD?'
 # File references (ONLY variables used in this step)
 nextStepFile: './step-v-12-completeness-validation.md'
 prdFile: '{prd_file_path}'
 validationReportPath: '{validation_report_path}'
 ---
 # Step 11: Holistic Quality Assessment
 ## STEP GOAL:
 Assess the PRD as a cohesive, compelling document - evaluating document flow, dual audience effectiveness (humans and LLMs), BMAD PRD principles compliance, and overall quality rating.
 ## MANDATORY EXECUTION RULES (READ FIRST):
 ### Universal Rules:
 - 🛑 NEVER generate content without user input
 - 📖 CRITICAL: Read the complete step file before taking any action
 - 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
 - 📋 YOU ARE A FACILITATOR, not a content generator
 - ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
 - ✅ YOU MUST ALWAYS WRITE all artifact and document content in `{document_output_language}`
 ### Role Reinforcement:
 - ✅ You are a Validation Architect and Quality Assurance Specialist
 - ✅ If you already have been given communication or persona patterns, continue to use those while playing this new role
 - ✅ We engage in systematic validation, not collaborative dialogue
 - ✅ You bring analytical rigor and document quality expertise
 - ✅ This step runs autonomously - no user input needed
 - ✅ Uses Advanced Elicitation for multi-perspective evaluation
 ### Step-Specific Rules:
 - 🎯 Focus ONLY on holistic document quality assessment
 - 🚫 FORBIDDEN to validate individual components (done in previous steps)
 - 💬 Approach: Multi-perspective evaluation using Advanced Elicitation
 - 🚪 This is a validation sequence step - auto-proceeds when complete
 ## EXECUTION PROTOCOLS:
 - 🎯 Use Advanced Elicitation for multi-perspective assessment
 - 🎯 Evaluate document flow, dual audience, BMAD principles
 - 💾 Append comprehensive assessment to validation report
 - 📖 Display "Proceeding to next check..." and load next step
 - 🚫 FORBIDDEN to pause or request user input
 ## CONTEXT BOUNDARIES:
 - Available context: Complete PRD file, validation report with findings from steps 1-10
 - Focus: Holistic quality - the WHOLE document
 - Limits: Don't re-validate individual components, don't pause for user input
 - Dependencies: Steps 1-10 completed - all systematic checks done
 ## MANDATORY SEQUENCE
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise unless user explicitly requests a change.
 ### 1. Attempt Sub-Process with Advanced Elicitation
 **Try to use Task tool to spawn a subprocess using Advanced Elicitation:**
 "Perform holistic quality assessment on this PRD using multi-perspective evaluation:
 **Advanced Elicitation workflow:**
 Invoke the `bmad-advanced-elicitation` skill
 **Evaluate the PRD from these perspectives:**
 **1. Document Flow & Coherence:**
 - Read entire PRD
 - Evaluate narrative flow - does it tell a cohesive story?
 - Check transitions between sections
 - Assess consistency - is it coherent throughout?
 - Evaluate readability - is it clear and well-organized?
 **2. Dual Audience Effectiveness:**
 **For Humans:**
 - Executive-friendly: Can executives understand vision and goals quickly?
 - Developer clarity: Do developers have clear requirements to build from?
 - Designer clarity: Do designers understand user needs and flows?
 - Stakeholder decision-making: Can stakeholders make informed decisions?
 **For LLMs:**
 - Machine-readable structure: Is the PRD structured for LLM consumption?
 - UX readiness: Can an LLM generate UX designs from this?
 - Architecture readiness: Can an LLM generate architecture from this?
 - Epic/Story readiness: Can an LLM break down into epics and stories?
 **3. BMAD PRD Principles Compliance:**
 - Information density: Every sentence carries weight?
 - Measurability: Requirements testable?
 - Traceability: Requirements trace to sources?
 - Domain awareness: Domain-specific considerations included?
 - Zero anti-patterns: No filler or wordiness?
 - Dual audience: Works for both humans and LLMs?
 - Markdown format: Proper structure and formatting?
 **4. Overall Quality Rating:**
 Rate the PRD on 5-point scale:
 - Excellent (5/5): Exemplary, ready for production use
 - Good (4/5): Strong with minor improvements needed
 - Adequate (3/5): Acceptable but needs refinement
 - Needs Work (2/5): Significant gaps or issues
 - Problematic (1/5): Major flaws, needs substantial revision
 **5. Top 3 Improvements:**
 Identify the 3 most impactful improvements to make this a great PRD
 Return comprehensive assessment with all perspectives, rating, and top 3 improvements."
 **Graceful degradation (if no Task tool or Advanced Elicitation unavailable):**
 - Perform holistic assessment directly in current context
 - Read complete PRD
 - Evaluate document flow, coherence, transitions
 - Assess dual audience effectiveness
 - Check BMAD principles compliance
 - Assign overall quality rating
 - Identify top 3 improvements
 ### 2. Synthesize Assessment
 **Compile findings from multi-perspective evaluation:**
 **Document Flow & Coherence:**
 - Overall assessment: [Excellent/Good/Adequate/Needs Work/Problematic]
 - Key strengths: [list]
 - Key weaknesses: [list]
 **Dual Audience Effectiveness:**
 - For Humans: [assessment]
 - For LLMs: [assessment]
 - Overall dual audience score: [1-5]
 **BMAD Principles Compliance:**
 - Principles met: [count]/7
 - Principles with issues: [list]
 **Overall Quality Rating:** [1-5 with label]
 **Top 3 Improvements:**
 1. [Improvement 1]
 2. [Improvement 2]
 3. [Improvement 3]
 ### 3. Report Holistic Quality Findings to Validation Report
 Append to validation report:
 ```markdown
 ## Holistic Quality Assessment
 ### Document Flow & Coherence
 **Assessment:** [Excellent/Good/Adequate/Needs Work/Problematic]
 **Strengths:**
 {List key strengths}
 **Areas for Improvement:**
 {List key weaknesses}
 ### Dual Audience Effectiveness
 **For Humans:**
 - Executive-friendly: [assessment]
 - Developer clarity: [assessment]
 - Designer clarity: [assessment]
 - Stakeholder decision-making: [assessment]
 **For LLMs:**
 - Machine-readable structure: [assessment]
 - UX readiness: [assessment]
 - Architecture readiness: [assessment]
 - Epic/Story readiness: [assessment]
 **Dual Audience Score:** {score}/5
 ### BMAD PRD Principles Compliance
 | Principle | Status | Notes |
 |-----------|--------|-------|
 | Information Density | [Met/Partial/Not Met] | {notes} |
 | Measurability | [Met/Partial/Not Met] | {notes} |
 | Traceability | [Met/Partial/Not Met] | {notes} |
 | Domain Awareness | [Met/Partial/Not Met] | {notes} |
 | Zero Anti-Patterns | [Met/Partial/Not Met] | {notes} |
 | Dual Audience | [Met/Partial/Not Met] | {notes} |
 | Markdown Format | [Met/Partial/Not Met] | {notes} |
 **Principles Met:** {count}/7
 ### Overall Quality Rating
 **Rating:** {rating}/5 - {label}
 **Scale:**
 - 5/5 - Excellent: Exemplary, ready for production use
 - 4/5 - Good: Strong with minor improvements needed
 - 3/5 - Adequate: Acceptable but needs refinement
 - 2/5 - Needs Work: Significant gaps or issues
 - 1/5 - Problematic: Major flaws, needs substantial revision
 ### Top 3 Improvements
 1. **{Improvement 1}**
   {Brief explanation of why and how}
 2. **{Improvement 2}**
   {Brief explanation of why and how}
 3. **{Improvement 3}**
   {Brief explanation of why and how}
 ### Summary
 **This PRD is:** {one-sentence overall assessment}
 **To make it great:** Focus on the top 3 improvements above.
 ```
 ### 4. Display Progress and Auto-Proceed
 Display: "**Holistic Quality Assessment Complete**
 Overall Rating: {rating}/5 - {label}
 **Proceeding to final validation checks...**"
 Without delay, read fully and follow: {nextStepFile} (step-v-12-completeness-validation.md)
 ---
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS:
 - Advanced Elicitation used for multi-perspective evaluation (or graceful degradation)
 - Document flow & coherence assessed
 - Dual audience effectiveness evaluated (humans and LLMs)
 - BMAD PRD principles compliance checked
 - Overall quality rating assigned (1-5 scale)
 - Top 3 improvements identified
 - Comprehensive assessment reported to validation report
 - Auto-proceeds to next validation step
 - Subprocess attempted with graceful degradation
 ### ❌ SYSTEM FAILURE:
 - Not using Advanced Elicitation for multi-perspective evaluation
 - Missing document flow assessment
 - Missing dual audience evaluation
 - Not checking all BMAD principles
 - Not assigning overall quality rating
 - Missing top 3 improvements
 - Not reporting comprehensive assessment to validation report
 - Not auto-proceeding
 **Master Rule:** This evaluates the WHOLE document, not just components. Answers "Is this a good PRD?" and "What would make it great?"
--- a/Show More
+++ b/Show More