bmad-method 6.0.5-next.0 → 6.0.5-next.10

package/.github/workflows/publish.yaml

@@ -56,85 +56,6 @@ jobs:
         run: |
           # npm trusted publishing requires Node >= 22.14.0 and npm >= 11.5.1.
           npm install --global npm@11.6.2
-          echo "Node: $(node --version)"
-          echo "npm: $(npm --version)"
-
-      - name: Debug npm auth config surface
-        run: |
-          USERCONFIG=$(npm config get userconfig)
-          echo "npm userconfig: $USERCONFIG"
-          if [ -f "$USERCONFIG" ]; then
-            if rg -n "_authToken|always-auth|registry.npmjs.org" "$USERCONFIG" >/dev/null 2>&1; then
-              echo "npm userconfig contains registry auth-related entries"
-              rg -n "_authToken|always-auth|registry.npmjs.org" "$USERCONFIG" | sed -E 's/(_authToken=).*/\1***MASKED***/'
-            else
-              echo "npm userconfig has no registry auth-related entries"
-            fi
-          else
-            echo "npm userconfig file not found"
-          fi
-
-      - name: Debug trusted publishing identity
-        run: |
-          echo "GitHub workflow context:"
-          echo "  repository: ${{ github.repository }}"
-          echo "  repository_owner: ${{ github.repository_owner }}"
-          echo "  ref: ${{ github.ref }}"
-          echo "  event_name: ${{ github.event_name }}"
-          echo "  workflow: ${{ github.workflow }}"
-          echo "  workflow_ref: ${{ github.workflow_ref }}"
-          echo "  actor: ${{ github.actor }}"
-          echo "  selected_channel: ${{ inputs.channel || 'n/a' }}"
-          echo "  selected_bump: ${{ inputs.bump || 'n/a' }}"
-          if [ "${NODE_AUTH_TOKEN+x}" = "x" ]; then
-            if [ -n "$NODE_AUTH_TOKEN" ]; then
-              echo "  node_auth_token_state: set-nonempty"
-            else
-              echo "  node_auth_token_state: set-empty"
-            fi
-          else
-            echo "  node_auth_token_state: unset"
-          fi
-
-          WORKFLOW_FILE=$(node -e "
-            const ref = process.argv[1] || '';
-            const match = ref.match(/\.github\/workflows\/([^@]+)@/);
-            process.stdout.write(match ? match[1] : '');
-          " "${{ github.workflow_ref }}")
-          echo "  workflow_filename_for_npm: ${WORKFLOW_FILE:-unknown}"
-
-          echo "OIDC claims (sanitized):"
-          RESPONSE=$(curl -fsS -H "Authorization: Bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" "${ACTIONS_ID_TOKEN_REQUEST_URL}&audience=npm:registry.npmjs.org")
-          ID_TOKEN=$(node -e "
-            const fs = require('fs');
-            const data = JSON.parse(fs.readFileSync(0, 'utf8'));
-            process.stdout.write(data.value || '');
-          " <<<"$RESPONSE")
-
-          node -e "
-            const token = process.argv[1];
-            if (!token) {
-              console.log(JSON.stringify({ error: 'missing_id_token' }, null, 2));
-              process.exit(0);
-            }
-            const payloadPart = token.split('.')[1] || '';
-            const padded = payloadPart.replace(/-/g, '+').replace(/_/g, '/') + '='.repeat((4 - (payloadPart.length % 4)) % 4);
-            const claims = JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
-            const out = {
-              iss: claims.iss,
-              sub: claims.sub,
-              aud: claims.aud,
-              repository: claims.repository,
-              repository_owner: claims.repository_owner,
-              workflow: claims.workflow,
-              workflow_ref: claims.workflow_ref,
-              job_workflow_ref: claims.job_workflow_ref,
-              ref: claims.ref,
-              environment: claims.environment || null,
-              runner_environment: claims.runner_environment || null,
-            };
-            console.log(JSON.stringify(out, null, 2));
-          " "$ID_TOKEN"
 
       - name: Configure git user
         if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
@@ -175,17 +96,6 @@ jobs:
         if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
         run: 'npm version ${{ inputs.bump }} -m "chore(release): v%s [skip ci]"'
 
-      - name: Debug publish target and registry state
-        run: |
-          echo "Local package target:"
-          node -e "
-            const pkg = require('./package.json');
-            console.log(JSON.stringify({ name: pkg.name, version: pkg.version }, null, 2));
-          "
-
-          echo "Registry package view (bmad-method):"
-          npm view bmad-method name version dist-tags --json || true
-
       - name: Publish prerelease to npm
         if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && inputs.channel == 'next')
         run: npm publish --tag next --provenance
@@ -194,26 +104,6 @@ jobs:
         if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
         run: npm publish --tag latest --provenance
 
-      - name: Print npm debug logs
-        if: always()
-        run: |
-          LOG_DIR="$HOME/.npm/_logs"
-          echo "npm log directory: $LOG_DIR"
-          ls -la "$LOG_DIR" || true
-
-          found=0
-          for file in "$LOG_DIR"/*-debug-0.log; do
-            [ -e "$file" ] || continue
-            found=1
-            echo "::group::npm-debug $(basename "$file")"
-            cat "$file"
-            echo "::endgroup::"
-          done
-
-          if [ "$found" -eq 0 ]; then
-            echo "No npm *-debug-0.log files found."
-          fi
-
       - name: Push version commit and tag
         if: github.event_name == 'workflow_dispatch' && inputs.channel == 'latest'
         run: git push origin main --follow-tags

package/CHANGELOG.md

@@ -47,7 +47,7 @@
 * Add CodeBuddy platform support with installer configuration (#1483)
 * Add LLM audit prompt for file reference conventions - new audit tool using parallel subagents (#1720)
 * Migrate Codex installer from `.codex/prompts` to `.agents/skills` format to align with Codex CLI changes (#1729)
-* Convert review-pr and audit-file-refs tools to proper bmad-os skills with slash commands `/bmad-os-review-pr` and `/bmad-os-audit-file-refs` (#1732)
+* Convert review-pr and audit-file-refs tools to proper bmad-os skills with slash commands `bmad-os-review-pr` and `bmad-os-audit-file-refs` (#1732)
 
 ### 🐛 Bug Fixes
 
@@ -365,7 +365,7 @@ V6 Stable Release! The End of Beta!
 - TEA documentation restructured using Diátaxis framework (25 docs)
 - Style guide optimized for LLM readers (367 lines, down from 767)
 - Glossary rewritten using table format (123 lines, down from 373)
-- README overhaul with numbered command flows and prominent `/bmad-help` callout
+- README overhaul with numbered command flows and prominent `bmad-help` callout
 - New workflow map diagram with interactive HTML
 - New editorial review tasks for document quality
 - E2E testing methodology for Game Dev Studio

package/README.md

@@ -13,7 +13,7 @@
 
 Traditional AI tools do the thinking for you, producing average results. BMad agents and facilitated workflows act as expert collaborators who guide you through a structured process to bring out your best thinking in partnership with the AI.
 
-- **AI Intelligent Help** — Ask `/bmad-help` anytime for guidance on what's next
+- **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)
@@ -40,7 +40,7 @@ Traditional AI tools do the thinking for you, producing average results. BMad ag
 npx bmad-method install
 ```
 
-> If you are getting a stale beta version, use: `npx bmad-method@6.0.1 install`
+> Want the newest prerelease build? Use `npx bmad-method@next install`. Expect higher churn than the default install.
 
 Follow the installer prompts, then open your AI IDE (Claude Code, Cursor, etc.) in your project folder.
 
@@ -52,7 +52,7 @@ npx bmad-method install --directory /path/to/project --modules bmm --tools claud
 
 [See all installation options](https://docs.bmad-method.org/how-to/non-interactive-installation/)
 
-> **Not sure what to do?** Run `/bmad-help` — it tells you exactly what's next and what's optional. You can also ask questions like `/bmad-help I just finished the architecture, what do I do next?`
+> **Not sure what to do?** Ask `bmad-help` — it tells you exactly what's next and what's optional. You can also ask questions like `bmad-help I just finished the architecture, what do I do next?`
 
 ## Modules
 

package/README_CN.md

@@ -13,7 +13,7 @@
 
 传统 AI 工具替你思考，产生平庸的结果。BMad 智能体和辅助工作流充当专家协作者，引导你通过结构化流程，与 AI 的合作发挥最佳思维，产出最有效优秀的结果。
 
-- **AI 智能帮助** — 随时使用 `/bmad-help` 获取下一步指导
+- **AI 智能帮助** — 随时使用 `bmad-help` 获取下一步指导
 - **规模-领域自适应** — 根据项目复杂度自动调整规划深度
 - **结构化工作流** — 基于分析、规划、架构和实施的敏捷最佳实践
 - **专业智能体** — 12+ 领域专家（PM、架构师、开发者、UX、Scrum Master 等）
@@ -52,7 +52,7 @@ npx bmad-method install --directory /path/to/project --modules bmm --tools claud
 
 [查看所有安装选项](http://docs.bmad-method.org/how-to/non-interactive-installation/)
 
-> **不确定该做什么？** 运行 `/bmad-help` — 它会准确告诉你下一步做什么以及什么是可选的。你也可以问诸如 `/bmad-help 我刚刚完成了架构设计，接下来该做什么？` 之类的问题。
+> **不确定该做什么？** 运行 `bmad-help` — 它会准确告诉你下一步做什么以及什么是可选的。你也可以问诸如 `bmad-help 我刚刚完成了架构设计，接下来该做什么？` 之类的问题。
 
 ## 模块
 

package/docs/explanation/quick-dev-new-preview.md

@@ -0,0 +1,73 @@
+---
+title: "Quick Dev New Preview"
+description: Reduce human-in-the-loop friction without giving up the checkpoints that protect output quality
+sidebar:
+  order: 2
+---
+
+`bmad-quick-dev-new-preview` is an experimental attempt to radically improve Quick Flow: intent in, code changes out, with lower ceremony and fewer human-in-the-loop turns without sacrificing quality.
+
+It lets the model run longer between checkpoints, then brings the human back only when the task cannot safely continue without human judgment or when it is time to review the end result.
+
+![Quick Dev New Preview workflow diagram](/diagrams/quick-dev-diagram.png)
+
+## Why This Exists
+
+Human-in-the-loop turns are necessary and expensive.
+
+Current LLMs still fail in predictable ways: they misread intent, fill gaps with confident guesses, drift into unrelated work, and generate noisy review output. At the same time, constant human intervention limits development velocity. Human attention is the bottleneck.
+
+This experimental version of Quick Flow is an attempt to rebalance that tradeoff. It trusts the model to run unsupervised for longer stretches, but only after the workflow has created a strong enough boundary to make that safe.
+
+## The Core Design
+
+### 1. Compress intent first
+
+The workflow starts by having the human and the model compress the request into one coherent goal. The input can begin as a rough expression of intent, but before the workflow runs autonomously it has to become small enough, clear enough, and contradiction-free enough to execute.
+
+Intent can come in many forms: a couple of phrases, a bug tracker link, output from plan mode, text copied from a chat session, or even a story number from BMAD's own `epics.md`. In that last case, the workflow will not understand BMAD story-tracking semantics, but it can still take the story itself and run with it.
+
+This workflow does not eliminate human control. It relocates it to a small number of high-value moments:
+
+- **Intent clarification** - turning a messy request into one coherent goal without hidden contradictions
+- **Spec approval** - confirming that the frozen understanding is the right thing to build
+- **Review of the final product** - the primary checkpoint, where the human decides whether the result is acceptable at the end
+
+### 2. Route to the smallest safe path
+
+Once the goal is clear, the workflow decides whether this is a true one-shot change or whether it needs the fuller path. Small, zero-blast-radius changes can go straight to implementation. Everything else goes through planning so the model has a stronger boundary before it runs longer on its own.
+
+### 3. Run longer with less supervision
+
+After that routing decision, the model can carry more of the work on its own. On the fuller path, the approved spec becomes the boundary the model executes against with less supervision, which is the whole point of the experiment.
+
+### 4. Diagnose failure at the right layer
+
+If the implementation is wrong because the intent was wrong, patching the code is the wrong fix. If the code is wrong because the spec was weak, patching the diff is also the wrong fix. The workflow is designed to diagnose where the failure entered the system, go back to that layer, and regenerate from there.
+
+Review findings are used to decide whether the problem came from intent, spec generation, or local implementation. Only truly local problems get patched locally.
+
+### 5. Bring the human back only when needed
+
+The intent interview is human-in-the-loop, but it is not the same kind of interruption as a recurring checkpoint. The workflow tries to keep those recurring checkpoints to a minimum. After the initial shaping of intent, the human mainly comes back when the workflow cannot safely continue without judgment and at the end, when it is time to review the result.
+
+- **Intent-gap resolution** - stepping back in when review proves the workflow could not safely infer what was meant
+
+Everything else is a candidate for longer autonomous execution. That tradeoff is deliberate. Older patterns spend more human attention on continuous supervision. Quick Dev New Preview spends more trust on the model, but saves human attention for the moments where human reasoning has the highest leverage.
+
+## Why the Review System Matters
+
+The review phase is not just there to find bugs. It is there to route correction without destroying momentum.
+
+This workflow works best on a platform that can spawn subagents, or at least invoke another LLM through the command line and wait for a result. If your platform does not support that natively, you can add a skill to do it. Context-free subagents are a cornerstone of the review design.
+
+Agentic reviews often go wrong in two ways:
+
+- They generate too many findings, forcing the human to sift through noise.
+- They derail the current change by surfacing unrelated issues and turning every run into an ad hoc cleanup project.
+
+Quick Dev New Preview addresses both by treating review as triage.
+
+Some findings belong to the current change. Some do not. If a finding is incidental rather than causally tied to the current work, the workflow can defer it instead of forcing the human to handle it immediately. That keeps the run focused and prevents random tangents from consuming the budget of attention.
+
+That triage will sometimes be imperfect. That is acceptable. It is usually better to misjudge some findings than to flood the human with thousands of low-value review comments. The system is optimizing for signal quality, not exhaustive recall.

package/docs/explanation/quick-flow.md

@@ -7,6 +7,10 @@ sidebar:
 
 Skip the ceremony. Quick Flow takes you from idea to working code in two skills - no Product Brief, no PRD, no Architecture doc.
 
+:::tip[Want a Unified Variant?]
+If you want one workflow to clarify, plan, implement, review, and present in a single run, see [Quick Dev New Preview](./quick-dev-new-preview.md).
+:::
+
 ## When to Use It
 
 - Bug fixes and patches

package/docs/how-to/get-answers-about-bmad.md

@@ -7,7 +7,7 @@ sidebar:
 
 ## Start Here: BMad-Help
 
-**The fastest way to get answers about BMad is `/bmad-help`.** This intelligent guide will answer upwards of 80% of all questions and is available to you directly in your IDE as you work.
+**The fastest way to get answers about BMad is the `bmad-help` skill.** This intelligent guide will answer upwards of 80% of all questions and is available to you directly in your IDE as you work.
 
 BMad-Help is more than a lookup tool — it:
 - **Inspects your project** to see what's already been completed
@@ -18,19 +18,23 @@ BMad-Help is more than a lookup tool — it:
 
 ### How to Use BMad-Help
 
-Run it with just the skill name:
+Call it by name in your AI session:
 
 ```
-/bmad-help
+bmad-help
 ```
 
-Or combine it with a natural language query:
+:::tip
+You can also use `/bmad-help` or `$bmad-help` depending on your platform, but just `bmad-help` should work everywhere.
+:::
+
+Combine it with a natural language query:
 
 ```
-/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?
-/bmad-help I'm stuck on the PRD workflow
-/bmad-help Show me what's been done so far
+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?
+bmad-help I'm stuck on the PRD workflow
+bmad-help Show me what's been done so far
 ```
 
 BMad-Help responds with:

package/docs/how-to/install-bmad.md

@@ -29,6 +29,15 @@ If you want to use a non interactive installer and provide all install options o
 npx bmad-method install
 ```
 
+:::tip[Want the newest prerelease build?]
+Use the `next` dist-tag:
+```bash
+npx bmad-method@next install
+```
+
+This gets you newer changes earlier, with a higher chance of churn than the default install.
+:::
+
 :::tip[Bleeding edge]
 To install the latest from the main branch (may be unstable):
 ```bash

package/docs/reference/testing.md

@@ -95,11 +95,11 @@ TEA also supports P0-P3 risk-based prioritization and optional integrations with
 
 ## How Testing Fits into Workflows
 
-Quinn's Automate workflow appears in Phase 4 (Implementation) of the BMad Method workflow map. A typical sequence:
+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:
 
-1. Implement a story with the Dev workflow (`DS`)
-2. Generate tests with Quinn (`QA`) or TEA's Automate workflow
-3. Validate implementation with Code Review (`CR`)
+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
+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.
 

package/docs/tutorials/getting-started.md

@@ -22,7 +22,7 @@ Build software faster using AI-powered workflows with specialized agents that gu
 
 :::tip[The Easiest Path]
 **Install** → `npx bmad-method install`
-**Ask** → `/bmad-help what should I do first?`
+**Ask** → `bmad-help what should I do first?`
 **Build** → Let BMad-Help guide you workflow by workflow
 :::
 
@@ -59,7 +59,7 @@ BMad-Help will respond with:
 BMad-Help doesn't just answer questions — **it automatically runs at the end of every workflow** to tell you exactly what to do next. No guessing, no searching docs — just clear guidance on the next required workflow.
 
 :::tip[Start Here]
-After installing BMad, run `/bmad-help` immediately. It will detect what modules you have installed and guide you to the right starting point for your project.
+After installing BMad, invoke the `bmad-help` skill immediately. It will detect what modules you have installed and guide you to the right starting point for your project.
 :::
 
 ## Understanding BMad
@@ -95,6 +95,8 @@ Open a terminal in your project directory and run:
 npx bmad-method install
 ```
 
+If you want the newest prerelease build instead of the default release channel, use `npx bmad-method@next install`.
+
 When prompted to select modules, choose **BMad Method**.
 
 The installer creates two folders:
@@ -105,14 +107,14 @@ The installer creates two folders:
 Open your AI IDE in the project folder and run:
 
 ```
-/bmad-help
+bmad-help
 ```
 
 BMad-Help will detect what you've completed and recommend exactly what to do next. You can also ask it questions like "What are my options?" or "I have a SaaS idea, where should I start?"
 :::
 
 :::note[How to Load Agents and Run Workflows]
-Each workflow has a **skill** you invoke in your IDE (e.g., `/bmad-create-prd`). Running a workflow skill automatically loads the appropriate agent — you don't need to load agents separately. You can also invoke an agent directly for general conversation (e.g., `/bmad-pm` for the PM agent).
+Each workflow has a **skill** you invoke by name in your IDE (e.g., `bmad-create-prd`). Your AI tool will recognize the `bmad-*` name and run it — you don't need to load agents separately. You can also invoke an agent skill directly for general conversation (e.g., `bmad-pm` for the PM agent).
 :::
 
 :::caution[Fresh Chats]
@@ -126,35 +128,35 @@ Work through phases 1-3. **Use fresh chats for each workflow.**
 :::tip[Project Context (Optional)]
 Before starting, consider creating `project-context.md` to document your technical preferences and implementation rules. This ensures all AI agents follow your conventions throughout the project.
 
-Create it manually at `_bmad-output/project-context.md` or generate it after architecture using `/bmad-generate-project-context`. [Learn more](../explanation/project-context.md).
+Create it manually at `_bmad-output/project-context.md` or generate it after architecture using `bmad-generate-project-context`. [Learn more](../explanation/project-context.md).
 :::
 
 ### Phase 1: Analysis (Optional)
 
 All workflows in this phase are optional:
-- **brainstorming** (`/bmad-brainstorming`) — Guided ideation
-- **research** (`/bmad-research`) — Market and technical research
-- **create-product-brief** (`/bmad-create-product-brief`) — Recommended foundation document
+- **brainstorming** (`bmad-brainstorming`) — Guided ideation
+- **research** (`bmad-research`) — Market and technical research
+- **create-product-brief** (`bmad-create-product-brief`) — Recommended foundation document
 
 ### Phase 2: Planning (Required)
 
 **For BMad Method and Enterprise tracks:**
-1. Invoke the **PM agent** (`/bmad-pm`) in a new chat
-2. Run the `bmad-create-prd` workflow (`/bmad-create-prd`)
+1. Invoke the **PM agent** (`bmad-pm`) in a new chat
+2. Run the `bmad-create-prd` workflow (`bmad-create-prd`)
 3. Output: `PRD.md`
 
 **For Quick Flow track:**
-- Use the `bmad-quick-spec` workflow (`/bmad-quick-spec`) instead of PRD, then skip to implementation
+- Use the `bmad-quick-spec` workflow (`bmad-quick-spec`) instead of PRD, then skip to implementation
 
 :::note[UX Design (Optional)]
-If your project has a user interface, invoke the **UX-Designer agent** (`/bmad-ux-designer`) and run the UX design workflow (`/bmad-create-ux-design`) after creating your PRD.
+If your project has a user interface, invoke the **UX-Designer agent** (`bmad-ux-designer`) and run the UX design workflow (`bmad-create-ux-design`) after creating your PRD.
 :::
 
 ### Phase 3: Solutioning (BMad Method/Enterprise)
 
 **Create Architecture**
-1. Invoke the **Architect agent** (`/bmad-architect`) in a new chat
-2. Run `bmad-create-architecture` (`/bmad-create-architecture`)
+1. Invoke the **Architect agent** (`bmad-architect`) in a new chat
+2. Run `bmad-create-architecture` (`bmad-create-architecture`)
 3. Output: Architecture document with technical decisions
 
 **Create Epics and Stories**
@@ -163,13 +165,13 @@ If your project has a user interface, invoke the **UX-Designer agent** (`/bmad-u
 Epics and stories are now created *after* architecture. This produces better quality stories because architecture decisions (database, API patterns, tech stack) directly affect how work should be broken down.
 :::
 
-1. Invoke the **PM agent** (`/bmad-pm`) in a new chat
-2. Run `bmad-create-epics-and-stories` (`/bmad-create-epics-and-stories`)
+1. Invoke the **PM agent** (`bmad-pm`) in a new chat
+2. Run `bmad-create-epics-and-stories` (`bmad-create-epics-and-stories`)
 3. The workflow uses both PRD and Architecture to create technically-informed stories
 
 **Implementation Readiness Check** *(Highly Recommended)*
-1. Invoke the **Architect agent** (`/bmad-architect`) in a new chat
-2. Run `bmad-check-implementation-readiness` (`/bmad-check-implementation-readiness`)
+1. Invoke the **Architect agent** (`bmad-architect`) in a new chat
+2. Run `bmad-check-implementation-readiness` (`bmad-check-implementation-readiness`)
 3. Validates cohesion across all planning documents
 
 ## Step 2: Build Your Project
@@ -178,7 +180,7 @@ Once planning is complete, move to implementation. **Each workflow should run in
 
 ### Initialize Sprint Planning
 
-Invoke the **SM agent** (`/bmad-sm`) and run `bmad-sprint-planning` (`/bmad-sprint-planning`). This creates `sprint-status.yaml` to track all epics and stories.
+Invoke the **SM agent** (`bmad-sm`) and run `bmad-sprint-planning` (`bmad-sprint-planning`). This creates `sprint-status.yaml` to track all epics and stories.
 
 ### The Build Cycle
 
@@ -186,11 +188,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        |
-| 2    | DEV   | `bmad-dev-story`    | `/bmad-dev-story`     | Implement the story                |
-| 3    | DEV   | `bmad-code-review`  | `/bmad-code-review`   | Quality validation *(recommended)* |
+| 1    | SM    | `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-sm`) and run `bmad-retrospective` (`/bmad-retrospective`).
+After completing all stories in an epic, invoke the **SM agent** (`bmad-sm`) and run `bmad-retrospective` (`bmad-retrospective`).
 
 ## What You've Accomplished
 
@@ -221,16 +223,16 @@ your-project/
 
 | Workflow                              | Command                                    | Agent     | Purpose                                         |
 | ------------------------------------- | ------------------------------------------ | --------- | ----------------------------------------------- |
-| **`bmad-help`** ⭐                    | `/bmad-help`                               | Any       | **Your intelligent guide — ask anything!**      |
-| `bmad-create-prd`                | `/bmad-create-prd`                     | PM        | Create Product Requirements Document            |
-| `bmad-create-architecture`            | `/bmad-create-architecture`            | Architect | Create architecture document                     |
-| `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-create-story`                   | `/bmad-create-story`                   | SM        | Create a story file                  |
-| `bmad-dev-story`                      | `/bmad-dev-story`                      | DEV       | Implement a story                    |
-| `bmad-code-review`                    | `/bmad-code-review`                    | DEV       | Review implemented code              |
+| **`bmad-help`** ⭐                    | `bmad-help`                               | Any       | **Your intelligent guide — ask anything!**      |
+| `bmad-create-prd`                | `bmad-create-prd`                     | PM        | Create Product Requirements Document            |
+| `bmad-create-architecture`            | `bmad-create-architecture`            | Architect | Create architecture document                     |
+| `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-create-story`                   | `bmad-create-story`                   | SM        | Create a story file                  |
+| `bmad-dev-story`                      | `bmad-dev-story`                      | DEV       | Implement a story                    |
+| `bmad-code-review`                    | `bmad-code-review`                    | DEV       | Review implemented code              |
 
 ## Common Questions
 
@@ -238,10 +240,10 @@ your-project/
 Only for BMad Method and Enterprise tracks. Quick Flow skips from tech-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 SM agent has a `bmad-correct-course` workflow (`bmad-correct-course`) for handling scope changes.
 
 **What if I want to brainstorm first?**
-Invoke the Analyst agent (`/bmad-analyst`) and run `bmad-brainstorming` (`/bmad-brainstorming`) before starting your PRD.
+Invoke the Analyst agent (`bmad-analyst`) and run `bmad-brainstorming` (`bmad-brainstorming`) before starting your PRD.
 
 **Do I need to follow a strict order?**
 Not strictly. Once you learn the flow, you can run workflows directly using the Quick Reference above.
@@ -249,7 +251,7 @@ Not strictly. Once you learn the flow, you can run workflows directly using the
 ## Getting Help
 
 :::tip[First Stop: BMad-Help]
-**Run `/bmad-help` anytime** — it's the fastest way to get unstuck. Ask it anything:
+**Invoke `bmad-help` anytime** — it's the fastest way to get unstuck. Ask it anything:
 - "What should I do after installing?"
 - "I'm stuck on workflow X"
 - "What are my options for Y?"
@@ -264,10 +266,10 @@ BMad-Help inspects your project, detects what you've completed, and tells you ex
 ## Key Takeaways
 
 :::tip[Remember These]
-- **Start with `/bmad-help`** — Your intelligent guide that knows your project and options
+- **Start with `bmad-help`** — Your intelligent guide that knows your project and options
 - **Always use fresh chats** — Start a new chat for each workflow
 - **Track matters** — Quick Flow uses quick-spec; Method/Enterprise need PRD and architecture
 - **BMad-Help runs automatically** — Every workflow ends with guidance on what's next
 :::
 
-Ready to start? Install BMad, run `/bmad-help`, and let your intelligent guide lead the way.
+Ready to start? Install BMad, invoke `bmad-help`, and let your intelligent guide lead the way.

package/docs/zh-cn/how-to/established-projects.md

@@ -61,16 +61,16 @@ sidebar:
 
 ### BMad-Help：你的起点
 
-**随时运行 `/bmad-help`，当你不确定下一步该做什么时。** 这个智能指南：
+**随时运行 `bmad-help`，当你不确定下一步该做什么时。** 这个智能指南：
 
 - 检查你的项目以查看已经完成了什么
 - 根据你安装的模块显示选项
 - 理解自然语言查询
 
 ```
-/bmad-help 我有一个现有的 Rails 应用，我应该从哪里开始？
-/bmad-help quick-flow 和完整方法有什么区别？
-/bmad-help 显示我有哪些可用的工作流程
+bmad-help 我有一个现有的 Rails 应用，我应该从哪里开始？
+bmad-help quick-flow 和完整方法有什么区别？
+bmad-help 显示我有哪些可用的工作流程
 ```
 
 BMad-Help 还会在**每个工作流程结束时自动运行**，提供关于下一步该做什么的清晰指导。

package/docs/zh-cn/how-to/get-answers-about-bmad.md

@@ -7,7 +7,7 @@ sidebar:
 
 ## 从这里开始：BMad-Help
 
-**获取关于 BMad 答案的最快方式是 `/bmad-help`。** 这个智能指南可以回答超过 80% 的问题，并且直接在您的 IDE 中可用，方便您工作时使用。
+**获取关于 BMad 答案的最快方式是 `bmad-help`。** 这个智能指南可以回答超过 80% 的问题，并且直接在您的 IDE 中可用，方便您工作时使用。
 
 BMad-Help 不仅仅是一个查询工具——它：
 - **检查您的项目**以查看已完成的内容
@@ -21,16 +21,16 @@ BMad-Help 不仅仅是一个查询工具——它：
 只需使用斜杠命令运行它：
 
 ```
-/bmad-help
+bmad-help
 ```
 
 或者结合自然语言查询：
 
 ```
-/bmad-help 我有一个 SaaS 想法并且知道所有功能。我应该从哪里开始？
-/bmad-help 我在 UX 设计方面有哪些选择？
-/bmad-help 我在 PRD 工作流上卡住了
-/bmad-help 向我展示到目前为止已完成的内容
+bmad-help 我有一个 SaaS 想法并且知道所有功能。我应该从哪里开始？
+bmad-help 我在 UX 设计方面有哪些选择？
+bmad-help 我在 PRD 工作流上卡住了
+bmad-help 向我展示到目前为止已完成的内容
 ```
 
 BMad-Help 会回应：

package/docs/zh-cn/how-to/install-bmad.md

@@ -77,7 +77,7 @@ your-project/
 
 ## 验证安装
 
-运行 `/bmad-help` 来验证一切正常并查看下一步操作。
+运行 `bmad-help` 来验证一切正常并查看下一步操作。
 
 **BMad-Help 是你的智能向导**，它会：
 - 确认你的安装正常工作
@@ -86,8 +86,8 @@ your-project/
 
 你也可以向它提问：
 ```
-/bmad-help 我刚安装完成，应该先做什么？
-/bmad-help 对于 SaaS 项目我有哪些选项？
+bmad-help 我刚安装完成，应该先做什么？
+bmad-help 对于 SaaS 项目我有哪些选项？
 ```
 
 ## 故障排除

package/docs/zh-cn/index.md

@@ -19,7 +19,7 @@ BMad 方法（**B**reakthrough **M**ethod of **A**gile AI **D**riven Development
 - **[工作流地图](./reference/workflow-map.md)** — BMM 阶段、工作流和上下文管理的可视化概览
 
 :::tip[只想直接上手？]
-安装 BMad 并运行 `/bmad-help` — 它会根据您的项目和已安装的模块引导您完成所有操作。
+安装 BMad 并运行 `bmad-help` — 它会根据您的项目和已安装的模块引导您完成所有操作。
 :::
 
 ## 如何使用本文档