docs: radical reduction of documentation scope for v6 beta (#1406)

* docs: radical reduction of documentation scope for v6 beta

Archive and basement unreviewed content to ship a focused, minimal doc set.

Changes:
- Archive stale how-to workflow guides (will rewrite for v6)
- Archive outdated explanation and reference content
- Move unreviewed content to basement for later review
- Reorganize TEA docs into dedicated /tea/ section
- Add workflow-map visual reference page
- Simplify getting-started tutorial and sidebar navigation
- Add explanation pages: brainstorming, adversarial-review, party-mode,
  quick-flow, advanced-elicitation
- Fix base URL handling for subdirectory deployments (GitHub Pages forks)

The goal is a minimal, accurate doc set for beta rather than
comprehensive but potentially misleading content.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* refactor: restructure BMM and agents documentation by consolidating and flattening index files.

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

docs/downloads.md

@@ -6,19 +6,21 @@ Download BMad Method resources for offline use, AI training, or integration.
 
 ## Source Bundles
 
+Download these from the `downloads/` folder on the documentation site.
+
 | File | Description |
 |------|-------------|
-| **[bmad-sources.zip](/downloads/bmad-sources.zip)** | Complete BMad source files |
+| `bmad-sources.zip` | Complete BMad source files |
-| **[bmad-prompts.zip](/downloads/bmad-prompts.zip)** | Agent and workflow prompts only |
+| `bmad-prompts.zip` | Agent and workflow prompts only |
 
 ## LLM-Optimized Files
 
-These files are designed for AI consumption - perfect for loading into Claude, ChatGPT, or any LLM context window.
+These files are designed for AI consumption - perfect for loading into Claude, ChatGPT, or any LLM context window. See [API Access](#api-access) below for URLs.
 
 | File | Description | Use Case |
 |------|-------------|----------|
-| **[llms.txt](/llms.txt)** | Documentation index with summaries | Quick overview, navigation |
+| `llms.txt` | Documentation index with summaries | Quick overview, navigation |
-| **[llms-full.txt](/llms-full.txt)** | Complete documentation concatenated | Full context loading |
+| `llms-full.txt` | Complete documentation concatenated | Full context loading |
 
 ### Using with LLMs
 
@@ -41,12 +43,12 @@ docs = requests.get("https://bmad-code-org.github.io/BMAD-METHOD/llms-full.txt")
 
 ## Installation Options
 
-### NPM (Recommended)
-
 ```bash
 npx bmad-method@alpha install
 ```
 
+[More details](/docs/how-to/install-bmad.md)
+
 ## Version Information
 
 - **Current Version:** See [CHANGELOG](https://github.com/bmad-code-org/BMAD-METHOD/blob/main/CHANGELOG.md)

docs/explanation/advanced-elicitation.md

@@ -0,0 +1,24 @@
+---
+title: "Advanced Elicitation"
+description: Push the LLM to rethink its work using structured reasoning methods
+---
+
+Make the LLM reconsider what it just generated. You pick a reasoning method, it applies that method to its own output, you decide whether to keep the improvements.
+
+Dozens of methods are built in - things like First Principles, Red Team vs Blue Team, Pre-mortem Analysis, Socratic Questioning, and more.
+
+## When to Use It
+
+- After a workflow generates content and you want alternatives
+- When output seems okay but you suspect there's more depth
+- To stress-test assumptions or find weaknesses
+- For high-stakes content where rethinking helps
+
+Workflows offer advanced elicitation at decision points - after the LLM has generated something, you'll be asked if you want to run it.
+
+## How It Works
+
+1. LLM suggests 5 relevant methods for your content
+2. You pick one (or reshuffle for different options)
+3. Method is applied, improvements shown
+4. Accept or discard, repeat or continue

docs/explanation/adversarial-review.md

@@ -0,0 +1,57 @@
+---
+title: "Adversarial Review"
+description: Forced reasoning technique that prevents lazy "looks good" reviews
+---
+
+Force deeper analysis by requiring problems to be found.
+
+## What is Adversarial Review?
+
+A review technique where the reviewer *must* find issues. No "looks good" allowed. The reviewer adopts a cynical stance - assume problems exist and find them.
+
+This isn't about being negative. It's about forcing genuine analysis instead of a cursory glance that rubber-stamps whatever was submitted.
+
+**The core rule:** You must find issues. Zero findings triggers a halt - re-analyze or explain why.
+
+## Why It Works
+
+Normal reviews suffer from confirmation bias. You skim the work, nothing jumps out, you approve it. The "find problems" mandate breaks this pattern:
+
+- **Forces thoroughness** - Can't approve until you've looked hard enough to find issues
+- **Catches missing things** - "What's not here?" becomes a natural question
+- **Improves signal quality** - Findings are specific and actionable, not vague concerns
+- **Information asymmetry** - Run reviews with fresh context (no access to original reasoning) so you evaluate the artifact, not the intent
+
+## Where It's Used
+
+Adversarial review appears throughout BMAD workflows - code review, implementation readiness checks, spec validation, and others. Sometimes it's a required step, sometimes optional (like advanced elicitation or party mode). The pattern adapts to whatever artifact needs scrutiny.
+
+## Human Filtering Required
+
+Because the AI is *instructed* to find problems, it will find problems - even when they don't exist. Expect false positives: nitpicks dressed as issues, misunderstandings of intent, or outright hallucinated concerns.
+
+**You decide what's real.** Review each finding, dismiss the noise, fix what matters.
+
+## Example
+
+Instead of:
+
+> "The authentication implementation looks reasonable. Approved."
+
+An adversarial review produces:
+
+> 1. **HIGH** - `login.ts:47` - No rate limiting on failed attempts
+> 2. **HIGH** - Session token stored in localStorage (XSS vulnerable)
+> 3. **MEDIUM** - Password validation happens client-side only
+> 4. **MEDIUM** - No audit logging for failed login attempts
+> 5. **LOW** - Magic number `3600` should be `SESSION_TIMEOUT_SECONDS`
+
+The first review might miss a security vulnerability. The second caught four.
+
+## Iteration and Diminishing Returns
+
+After addressing findings, consider running it again. A second pass usually catches more. A third isn't always useless either. But each pass takes time, and eventually you hit diminishing returns - just nitpicks and false findings.
+
+:::tip[Better Reviews]
+Assume problems exist. Look for what's missing, not just what's wrong.
+:::

docs/explanation/brainstorming.md

@@ -0,0 +1,31 @@
+---
+title: "Brainstorming"
+description: Interactive creative sessions using 60+ proven ideation techniques
+---
+
+Unlock your creativity through guided exploration.
+
+## What is Brainstorming?
+
+Run `brainstorming` and you've got a creative facilitator pulling ideas out of you - not generating them for you. The AI acts as coach and guide, using proven techniques to create conditions where your best thinking emerges.
+
+**Good for:**
+
+- Breaking through creative blocks
+- Generating product or feature ideas
+- Exploring problems from new angles
+- Developing raw concepts into action plans
+
+## How It Works
+
+1. **Setup** - Define topic, goals, constraints
+2. **Choose approach** - Pick techniques yourself, get AI recommendations, go random, or follow a progressive flow
+3. **Facilitation** - Work through techniques with probing questions and collaborative coaching
+4. **Organize** - Ideas grouped into themes and prioritized
+5. **Action** - Top ideas get next steps and success metrics
+
+Everything gets captured in a session document you can reference later or share with stakeholders.
+
+:::note[Your Ideas]
+Every idea comes from you. The workflow creates conditions for insight - you're the source.
+:::

docs/explanation/features/advanced-elicitation.md

@@ -1,95 +0,0 @@
----
-title: "Advanced Elicitation"
----
-
-Push the LLM to rethink its work through 50+ reasoning methods — essentially, LLM brainstorming.
-
-Advanced Elicitation is the inverse of Brainstorming. Instead of pulling ideas out of you, the LLM applies sophisticated reasoning techniques to re-examine and enhance content it has just generated. It's the LLM brainstorming with itself to find better approaches, uncover hidden issues, and discover improvements it missed on the first pass.
-
-## When to Use It
-
-- After a workflow generates a section of content and you want to explore alternatives
-- When the LLM's initial output seems adequate but you suspect there's more depth available
-- For high-stakes content where multiple perspectives would strengthen the result
-- To stress-test assumptions, explore edge cases, or find weaknesses in generated plans
-- When you want the LLM to "think again" but with structured reasoning methods
-
-## How It Works
-
-### 1. Context Analysis
-The LLM analyzes the current content, understanding its type, complexity, stakeholder needs, risk level, and creative potential.
-
-### 2. Smart Method Selection
-Based on context, 5 methods are intelligently selected from a library of 50+ techniques and presented to you:
-
-| Option            | Description                              |
-| ----------------- | ---------------------------------------- |
-| **1-5**           | Apply the selected method to the content |
-| **[r] Reshuffle** | Get 5 new methods selected randomly      |
-| **[a] List All**  | Browse the complete method library       |
-| **[x] Proceed**   | Continue with enhanced content           |
-
-### 3. Method Execution & Iteration
-- The selected method is applied to the current content
-- Improvements are shown for your review
-- You choose whether to apply changes or discard them
-- The menu re-appears for additional elicitations
-- Each method builds on previous enhancements
-
-### 4. Party Mode Integration (Optional)
-If Party Mode is active, BMad agents participate randomly in the elicitation process, adding their unique perspectives to the methods.
-
-## Method Categories
-
-| Category          | Focus                               | Example Methods                                                |
-| ----------------- | ----------------------------------- | -------------------------------------------------------------- |
-| **Core**          | Foundational reasoning techniques   | First Principles Analysis, 5 Whys, Socratic Questioning        |
-| **Collaboration** | Multiple perspectives and synthesis | Stakeholder Round Table, Expert Panel Review, Debate Club      |
-| **Advanced**      | Complex reasoning frameworks        | Tree of Thoughts, Graph of Thoughts, Self-Consistency          |
-| **Competitive**   | Adversarial stress-testing          | Red Team vs Blue Team, Shark Tank Pitch, Code Review Gauntlet  |
-| **Technical**     | Architecture and code quality       | Decision Records, Rubber Duck Debugging, Algorithm Olympics    |
-| **Creative**      | Innovation and lateral thinking     | SCAMPER, Reverse Engineering, Random Input Stimulus            |
-| **Research**      | Evidence-based analysis             | Literature Review Personas, Thesis Defense, Comparative Matrix |
-| **Risk**          | Risk identification and mitigation  | Pre-mortem Analysis, Failure Mode Analysis, Chaos Monkey       |
-| **Learning**      | Understanding verification          | Feynman Technique, Active Recall Testing                       |
-| **Philosophical** | Conceptual clarity                  | Occam's Razor, Ethical Dilemmas                                |
-| **Retrospective** | Reflection and lessons              | Hindsight Reflection, Lessons Learned Extraction               |
-
-## Key Features
-
-- **50+ reasoning methods** — Spanning core logic to advanced multi-step reasoning frameworks
-- **Smart context selection** — Methods chosen based on content type, complexity, and stakeholder needs
-- **Iterative enhancement** — Each method builds on previous improvements
-- **User control** — Accept or discard each enhancement before proceeding
-- **Party Mode integration** — Agents can participate when Party Mode is active
-
-## Workflow Integration
-
-Advanced Elicitation is a core workflow designed to be invoked by other workflows during content generation:
-
-| Parameter              | Description                                               |
-| ---------------------- | --------------------------------------------------------- |
-| **Content to enhance** | The current section content that was just generated       |
-| **Context type**       | The kind of content being created (spec, code, doc, etc.) |
-| **Enhancement goals**  | What the calling workflow wants to improve                |
-
-### Integration Flow
-
-When called from a workflow:
-1. Receives the current section content that was just generated
-2. Applies elicitation methods iteratively to enhance that content
-3. Returns the enhanced version when user selects 'x' to proceed
-4. The enhanced content replaces the original section in the output document
-
-### Example
-
-A specification generation workflow could invoke Advanced Elicitation after producing each major section (requirements, architecture, implementation plan). The workflow would pass the generated section, and Advanced Elicitation would offer methods like "Stakeholder Round Table" to gather diverse perspectives on requirements, or "Red Team vs Blue Team" to stress-test the architecture for vulnerabilities.
-
-## Advanced Elicitation vs. Brainstorming
-
-|              | **Advanced Elicitation**                          | **Brainstorming**                             |
-| ------------ | ------------------------------------------------- | --------------------------------------------- |
-| **Source**   | LLM generates ideas through structured reasoning  | User provides ideas, AI coaches them out      |
-| **Purpose**  | Rethink and improve LLM's own output              | Unlock user's creativity                      |
-| **Methods**  | 50+ reasoning and analysis techniques             | 60+ ideation and creativity techniques        |
-| **Best for** | Enhancing generated content, finding alternatives | Breaking through blocks, generating new ideas |

docs/explanation/features/brainstorming-techniques.md

@@ -1,92 +0,0 @@
----
-title: "Brainstorming"
----
-
-Facilitate structured creative sessions using 60+ proven ideation techniques.
-
-The Brainstorming workflow is an interactive facilitation system that helps you unlock your own creativity. The AI acts as coach, guide, and creative partner — using proven techniques to draw out ideas and insights that are already within you.
-
-:::note[Important]
-Every idea comes from you. The workflow creates the conditions for your best thinking to emerge through guided exploration, but you are the source.
-:::
-
-## When to Use It
-
-- Breaking through creative blocks on a specific challenge
-- Generating innovative ideas for products, features, or solutions
-- Exploring a problem from completely new angles
-- Systematically developing ideas from raw concepts to actionable plans
-- Team ideation (with collaborative techniques) or personal creative exploration
-
-## How It Works
-
-### 1. Session Setup
-Define your topic, goals, and any constraints.
-
-### 2. Choose Your Approach
-
-| Approach | Description |
-|----------|-------------|
-| **User-Selected** | Browse the full technique library and pick what appeals to you |
-| **AI-Recommended** | Get customized technique suggestions based on your goals |
-| **Random Selection** | Discover unexpected methods through serendipitous technique combinations |
-| **Progressive Flow** | Journey systematically from expansive exploration to focused action planning |
-
-### 3. Interactive Facilitation
-Work through techniques with true collaborative coaching. The AI asks probing questions, builds on your ideas, and helps you think deeper—but your ideas are the source.
-
-### 4. Idea Organization
-All your generated ideas are organized into themes and prioritized.
-
-### 5. Action Planning
-Top ideas get concrete next steps, resource requirements, and success metrics.
-
-## What You Get
-
-A comprehensive session document that captures the entire journey:
-
-- Topic, goals, and session parameters
-- Each technique used and how it was applied
-- Your contributions and the ideas you generated
-- Thematic organization connecting related insights
-- Prioritized ideas with action plans
-- Session highlights and key breakthroughs
-
-This document becomes a permanent record of your creative process — valuable for future reference, sharing with stakeholders, or continuing the session later.
-
-## Technique Categories
-
-| Category | Focus |
-|----------|-------|
-| **Collaborative** | Team dynamics and inclusive participation |
-| **Creative** | Breakthrough thinking and paradigm shifts |
-| **Deep** | Root cause analysis and strategic insight |
-| **Structured** | Organized frameworks and systematic exploration |
-| **Theatrical** | Playful, radical perspectives |
-| **Wild** | Boundary-pushing, extreme thinking |
-| **Biomimetic** | Nature-inspired solutions |
-| **Quantum** | Quantum principles for innovation |
-| **Cultural** | Traditional knowledge and cross-cultural approaches |
-| **Introspective Delight** | Inner wisdom and authentic exploration |
-
-## Key Features
-
-- **Interactive coaching** — Pulls ideas *out* of you, doesn't generate them for you
-- **On-demand loading** — Techniques loaded from a comprehensive library as needed
-- **Session preservation** — Every step, insight, and action plan is documented
-- **Continuation support** — Pause sessions and return later, or extend with additional techniques
-
-## Workflow Integration
-
-Brainstorming is a core workflow designed to be invoked and configured by other modules. When called from another workflow, it accepts contextual parameters:
-
-| Parameter | Description |
-|-----------|-------------|
-| **Topic focus** | What the brainstorming should help discover or solve |
-| **Guardrails** | Constraints, boundaries, or must-avoid areas |
-| **Output goals** | What the final output needs to accomplish for the calling workflow |
-| **Context files** | Project-specific guidance to inform technique selection |
-
-### Example
-
-When creating a new module in the BMad Builder workflow, Brainstorming can be invoked with guardrails around the module's purpose and a goal to discover key features, user needs, or architectural considerations. The session becomes focused on producing exactly what the module creation workflow needs.

docs/explanation/features/party-mode.md

@@ -1,95 +0,0 @@
----
-title: "Party Mode: Multi-Agent Collaboration"
----
-
-Get all your AI agents in one conversation.
-
-## What is Party Mode?
-
-Ever wanted to gather your entire AI team in one room and see what happens? That's party mode.
-
-Type `/bmad:core:workflows:party-mode` (or `*party-mode` from any agent or at key workflow junctions when asked), and suddenly you've got **all your AI agents** in one conversation. PM, Architect, DEV, UX Designer and more that you can choose from.
-
-**Why it's useful:**
-
-- **After complex workflows** - Debrief with the whole team about what worked, what didn't
-- **Big decisions with tradeoffs** - Get technical, creative, and strategic perspectives simultaneously
-- **Brainstorming sessions** - Watch ideas evolve through cross-pollination
-- **When things go wrong** - Call out failures, watch agents defend their decisions, let them debate whose fault it was (oddly therapeutic)
-- **Sprint retrospectives** - Party mode powers the retrospective workflow
-- **Sprint planning** - Multi-agent collaboration for planning sessions
-
-## How It Works
-
-**The basics:**
-
-1. Party mode reads `_bmad/_config/agent-manifest.csv`
-2. Loads ALL installed agents (already includes your customizations from install)
-3. BMad Master orchestrates - picks 2-3 relevant agents per message based on topic
-4. Agents respond in character, can agree/disagree/build on each other's ideas
-5. Discussion continues until you type "exit" or reach natural conclusion
-
-**That's it.** No complex merging, no runtime magic. Just agents talking.
-
-## Quick Start
-
-```bash
-/bmad:core:workflows:party-mode
-
-*party-mode
-
-
-/bmad:core:workflows:party-mode and include also in the party Santa Clause and Einstein 
-
-Ask questions, respond to agents, direct the conversation
-
-Type: exit
-```
-
-## Fun Examples
-
-### Example 1: Calling Out Bad Architecture
-
-**You:** "Okay team, our last sprint was a disaster. The authentication service went down three times. Who screwed this up?"
-
-**Architect (Winston):** "The design was sound - distributed authentication with proper fallbacks. If implementation deviated from the spec..."
-
-**DEV (Amelia):** "I followed the architecture doc exactly. The spec didn't account for concurrent session invalidation race conditions."
-
-**PM (John):** "Both of you missed the bigger issue - we didn't validate session management requirements in the PRD. This is on me for not catching it."
-
-**TEA (Murat):** "And I should've caught this in integration tests. The test scenarios didn't cover concurrent invalidation."
-
-_(Watch them debate whose fault it really was - it's therapeutic)_
-
-### Example 2: Creative Brainstorming
-
-**You:** "How do we make onboarding feel magical instead of boring?"
-
-**UX Designer (Sally):** "Start with progressive disclosure - reveal features as users need them, not all at once in a tutorial."
-
-**Storyteller (CIS):** "What if onboarding was a story? Each step reveals a character's journey - the user IS the hero."
-
-**Innovation Strategist (CIS):** "Take it further - gamify with unlockable achievements. But make them meaningful, not arbitrary badges."
-
-**Game Designer:** "Building on that - what if the first 'quest' is actually solving a real user problem? They learn by doing something valuable."
-
-_(Ideas cross-pollinate and evolve)_
-
-### Example 3: Technical Decision
-
-**You:** "Monolith or microservices for MVP?"
-
-**Architect:** "Start monolith. Microservices add complexity you don't need at 1000 users."
-
-**PM:** "Agree. Time to market matters more than theoretical scalability."
-
-**DEV:** "Monolith with clear module boundaries. We can extract services later if needed."
-
-**Innovation Strategist:** "Contrarian take - if your differentiator IS scalability, build for it now. Otherwise Architect's right."
-
-_(Multiple perspectives reveal the right answer)_
-
-:::tip[Better Decisions]
-Better decisions through diverse perspectives. Welcome to party mode.
-:::

docs/explanation/features/quick-flow.md

@@ -1,149 +0,0 @@
----
-title: "Quick Spec Flow"
-description: Understanding Quick Spec Flow for rapid development in BMad Method
----
-
-Quick Spec Flow is a streamlined alternative to the full BMad Method for Quick Flow track projects. Instead of going through Product Brief → PRD → Architecture, you go straight to a context-aware technical specification and start coding.
-
-- **Perfect for:** Bug fixes, small features, rapid prototyping, and quick enhancements
-- **Time to implementation:** Minutes, not hours
-
-## When to Use Quick Flow
-
-### Use Quick Flow when:
-
-- Single bug fix or small enhancement
-- Small feature with clear scope (typically 1-15 stories)
-- Rapid prototyping or experimentation
-- Adding to existing brownfield codebase
-- You know exactly what you want to build
-
-### Use BMad Method or Enterprise when:
-
-- Building new products or major features
-- Need stakeholder alignment
-- Complex multi-team coordination
-- Requires extensive planning and architecture
-
-:::tip[Not Sure?]
-Run `workflow-init` to get a recommendation based on your project's needs.
-:::
-
-## Quick Flow Overview
-
-```mermaid
-flowchart TD
-    START[Step 1: Run Tech-Spec Workflow]
-    DETECT[Detects project stack]
-    ANALYZE[Analyzes brownfield codebase]
-    TEST[Detects test frameworks]
-    CONFIRM[Confirms conventions]
-    GENERATE[Generates context-rich tech-spec]
-    STORIES[Creates ready-to-implement stories]
-    IMPL[Step 2: Implement with DEV Agent]
-    DONE[DONE!]
-
-    START --> DETECT
-    DETECT --> ANALYZE
-    ANALYZE --> TEST
-    TEST --> CONFIRM
-    CONFIRM --> GENERATE
-    GENERATE --> STORIES
-    STORIES --> IMPL
-    IMPL --> DONE
-
-    style START fill:#bfb,stroke:#333,stroke-width:2px
-    style IMPL fill:#bbf,stroke:#333,stroke-width:2px
-    style DONE fill:#f9f,stroke:#333,stroke-width:3px
-```
-
-## What Makes It Quick
-
-- No Product Brief needed
-- No PRD needed
-- No Architecture doc needed
-- Auto-detects your stack
-- Auto-analyzes brownfield code
-- Auto-validates quality
-- Story context optional (tech-spec is comprehensive)
-
-## Smart Context Discovery
-
-Quick Spec Flow automatically discovers and uses:
-
-### Existing Documentation
-- Product briefs (if they exist)
-- Research documents
-- `document-project` output (brownfield codebase map)
-
-### Project Stack
-- **Node.js:** package.json → frameworks, dependencies, scripts
-- **Python:** requirements.txt, pyproject.toml → packages, tools
-- **Ruby:** Gemfile → gems and versions
-- **Java:** pom.xml, build.gradle → Maven/Gradle dependencies
-- **Go:** go.mod → modules
-- **Rust:** Cargo.toml → crates
-
-### Brownfield Code Patterns
-- Directory structure and organization
-- Existing code patterns (class-based, functional, MVC)
-- Naming conventions
-- Test frameworks and patterns
-- Code style configurations
-
-### Convention Confirmation
-
-Quick Spec Flow detects your conventions and **asks for confirmation**:
-
-```
-I've detected these conventions in your codebase:
-
-Code Style:
-- ESLint with Airbnb config
-- Prettier with single quotes
-
-Test Patterns:
-- Jest test framework
-- .test.js file naming
-
-Should I follow these existing conventions? (yes/no)
-```
-
-**You decide:** Conform to existing patterns or establish new standards!
-
-## Auto-Validation
-
-Quick Spec Flow **automatically validates** everything:
-
-- Context gathering completeness
-- Definitiveness (no "use X or Y" statements)
-- Brownfield integration quality
-- Stack alignment
-- Implementation readiness
-
-## Comparison: Quick Flow vs Full BMM
-
-| Aspect                | Quick Flow Track             | BMad Method/Enterprise Tracks      |
-| --------------------- | ---------------------------- | ---------------------------------- |
-| **Setup**             | None (standalone)            | workflow-init recommended          |
-| **Planning Docs**     | tech-spec.md only            | Product Brief → PRD → Architecture |
-| **Time to Code**      | Minutes                      | Hours to days                      |
-| **Best For**          | Bug fixes, small features    | New products, major features       |
-| **Context Discovery** | Automatic                    | Manual + guided                    |
-| **Validation**        | Auto-validates everything    | Manual validation steps            |
-| **Brownfield**        | Auto-analyzes and conforms   | Manual documentation required      |
-
-## When to Graduate to BMad Method
-
-Start with Quick Flow, but switch to BMad Method when:
-
-- Project grows beyond initial scope
-- Multiple teams need coordination
-- Stakeholders need formal documentation
-- Product vision is unclear
-- Architectural decisions need deep analysis
-- Compliance/regulatory requirements exist
-
-:::tip[Transition Tip]
-You can always run `workflow-init` later to transition from Quick Flow to BMad Method.
-:::

docs/explanation/party-mode.md

@@ -0,0 +1,57 @@
+---
+title: "Party Mode"
+description: Multi-agent collaboration - get all your AI agents in one conversation
+---
+
+Get all your AI agents in one conversation.
+
+## What is Party Mode?
+
+Run `party-mode` and you've got your whole AI team in one room - PM, Architect, Dev, UX Designer, whoever you need. BMad Master orchestrates, picking relevant agents per message. Agents respond in character, agree, disagree, and build on each other's ideas.
+
+The conversation continues as long as you want. Ask follow-ups, push back on answers, redirect the discussion - it's a real back-and-forth with your agents until you're done.
+
+**Good for:**
+
+- Big decisions with tradeoffs
+- Brainstorming sessions
+- Post-mortems when things go wrong
+- Sprint retrospectives and planning
+
+## Examples
+
+### Calling Out Bad Architecture
+
+**You:** "Okay team, our last sprint was a disaster. The authentication service went down three times. Who screwed this up?"
+
+**Architect:** "The design was sound - distributed authentication with proper fallbacks. If implementation deviated from the spec..."
+
+**Dev:** "I followed the architecture doc exactly. The spec didn't account for concurrent session invalidation race conditions."
+
+**PM:** "Both of you missed the bigger issue - we didn't validate session management requirements in the PRD. This is on me for not catching it."
+
+**TEA:** "And I should've caught this in integration tests. The test scenarios didn't cover concurrent invalidation."
+
+### Creative Brainstorming
+
+**You:** "How do we make onboarding feel magical instead of boring?"
+
+**UX Designer:** "Start with progressive disclosure - reveal features as users need them, not all at once in a tutorial."
+
+**Storyteller:** "What if onboarding was a story? Each step reveals a character's journey - the user IS the hero."
+
+**Game Designer:** "Building on that - what if the first 'quest' is actually solving a real user problem? They learn by doing something valuable."
+
+### Technical Decision
+
+**You:** "Monolith or microservices for MVP?"
+
+**Architect:** "Start monolith. Microservices add complexity you don't need at 1000 users."
+
+**PM:** "Agree. Time to market matters more than theoretical scalability."
+
+**Dev:** "Monolith with clear module boundaries. We can extract services later if needed."
+
+:::tip[Better Decisions]
+Better decisions through diverse perspectives. Welcome to party mode.
+:::

docs/explanation/quick-flow.md

@@ -0,0 +1,27 @@
+---
+title: "Quick Flow"
+description: Fast-track for small changes - skip the full methodology
+---
+
+Quick Flow is for when you don't need the full BMad Method. Skip Product Brief, PRD, and Architecture - go straight to implementation.
+
+## How It Works
+
+1. **Run `quick-spec`** — generates a focused tech-spec
+2. **Run `quick-dev`** — implements it
+
+That's it.
+
+## When to Use It
+
+- Bug fixes
+- Refactoring
+- Small features
+- Prototyping
+
+## When to Use Full BMad Method Instead
+
+- New products
+- Major features
+- Multiple teams involved
+- Stakeholder alignment needed

docs/how-to/customization/index.md

@@ -1,23 +0,0 @@
----
-title: "BMad Customization"
----
-
-Personalize agents and workflows to match your needs.
-
-## Guides
-
-| Guide | Description |
-|-------|-------------|
-| **[Agent Customization](/docs/how-to/customization/customize-agents.md)** | Modify agent behavior without editing core files |
-
-## Overview
-
-BMad provides two main customization approaches:
-
-### Agent Customization
-
-Modify any agent's persona, name, capabilities, or menu items using `.customize.yaml` files in `_bmad/_config/agents/`. Your customizations persist through updates.
-
-### Workflow Customization
-
-Replace or extend workflow steps to create tailored processes. (Coming soon)

docs/how-to/install-bmad.md

@@ -0,0 +1,89 @@
+---
+title: "How to Install BMad"
+description: Step-by-step guide to installing BMad in your project
+---
+
+Use the `npx bmad-method install` command to set up BMad in your project with your choice of modules and AI tools.
+
+## When to Use This
+
+- Starting a new project with BMad
+- Adding BMad to an existing codebase
+- Update the existing BMad Installation
+
+:::note[Prerequisites]
+- **Node.js** 20+ (required for the installer)
+- **Git** (recommended)
+- **AI tool** (Claude Code, Cursor, Windsurf, or similar)
+:::
+
+## Steps
+
+### 1. Run the Installer
+
+```bash
+npx bmad-method@alpha install
+```
+
+### 2. Choose Installation Location
+
+The installer will ask where to install BMad files:
+
+- Current directory (recommended for new projects if you created the directory yourself and ran from within the directory)
+- Custom path
+
+### 3. Select Your AI Tools
+
+Pick which AI tools you use:
+
+- Claude Code
+- Cursor
+- Windsurf
+- Others
+
+Each tool has its own way of integrating commands. The installer creates tiny prompt files to activate workflows and agents — it just puts them where your tool expects to find them.
+
+### 4. Choose Modules
+
+The installer shows available modules. Select whichever ones you need — most users just want **BMad Method** (the software development module).
+
+### 5. Follow the Prompts
+
+The installer guides you through the rest — custom content, settings, etc.
+
+## What You Get
+
+```
+your-project/
+├── _bmad/
+│   ├── bmm/            # Your selected modules
+│   │   └── config.yaml # Module settings (if you ever need to change them)
+│   ├── core/           # Required core module
+│   └── ...
+├── _bmad-output/       # Generated artifacts
+└── .claude/            # Claude Code commands (if using Claude Code)
+```
+
+## Verify Installation
+
+Run the `help` workflow (`/bmad-help` on most platforms) to verify everything works and see what to do next.
+
+## Living on the Edge
+
+**Latest pre-release (alpha/beta):**
+```bash
+npx bmad-method@alpha install
+```
+
+**Latest from main branch:**
+```bash
+npx github:bmad-code-org/BMAD-METHOD install
+```
+
+Use these if you want the newest features before they're officially released. Things might break.
+
+## Troubleshooting
+
+**Installer throws an error** — Copy-paste the output into your AI assistant and let it figure it out.
+
+**Installer worked but something doesn't work later** — Your AI needs BMad context to help. See [How to Get Answers About BMad](/docs/how-to/get-answers-about-bmad.md) for how to point your AI at the right sources.

docs/how-to/installation/index.md

@@ -1,12 +0,0 @@
----
-title: "Installation Guides"
-description: How to install and upgrade BMad Method
----
-
-How-to guides for installing and configuring the BMad Method.
-
-| Guide | Description |
-|-------|-------------|
-| [Install BMad](/docs/how-to/installation/install-bmad.md) | Step-by-step installation instructions |
-| [Install Custom Modules](/docs/how-to/installation/install-custom-modules.md) | Add custom agents, workflows, and modules |
-| [Upgrade to v6](/docs/how-to/installation/upgrade-to-v6.md) | Migrate from BMad v4 to v6 |

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

@@ -1,111 +0,0 @@
----
-title: "How to Install BMad"
-description: Step-by-step guide to installing BMad in your project
----
-
-Use the `npx bmad-method install` command to set up BMad in your project with your choice of modules and AI tools.
-
-## When to Use This
-
-- Starting a new project with BMad
-- Adding BMad to an existing codebase
-- Update the existing BMad Installation
-
-:::note[Prerequisites]
-- **Node.js** 20+ (required for the installer)
-- **Git** (recommended)
-- **AI-powered IDE** (Claude Code, Cursor, Windsurf, or similar)
-:::
-
-## Steps
-
-### 1. Run the Installer
-
-```bash
-npx bmad-method install
-```
-
-### 2. Choose Installation Location
-
-The installer will ask where to install BMad files:
-
-- Current directory (recommended for new projects if you created the directory yourself and ran from within the directory)
-- Custom path
-
-### 3. Select Your AI Tools
-
-Choose which AI tools you'll be using:
-
-- Claude Code
-- Cursor
-- Windsurf
--  Many others to choose from
-
-The installer configures BMad for your selected tools by setting up commands that will call the ui.
-
-### 4. Choose Modules
-
-Select which modules to install:
-
-| Module   | Purpose                                   |
-| -------- | ----------------------------------------- |
-| **BMM**  | Core methodology for software development |
-| **BMGD** | Game development workflows                |
-| **CIS**  | Creative intelligence and facilitation    |
-| **BMB**  | Building custom agents and workflows      |
-
-### 5. Add Custom Content (Optional)
-
-If you have custom agents, workflows, or modules, point to their location and the installer will integrate them.
-
-### 6. Configure Settings
-
-For each module, either accept recommended defaults (faster) or customize settings (more control).
-
-## What You Get
-
-```
-your-project/
-├── _bmad/
-│   ├── bmm/            # Method module
-│   │   ├── agents/     # Agent files
-│   │   ├── workflows/  # Workflow files
-│   │   └── config.yaml # Module config
-│   ├── core/           # Core utilities
-│   └── ...
-├── _bmad-output/       # Generated artifacts
-└── .claude/            # IDE configuration
-```
-
-## Verify Installation
-
-1. Check the `_bmad/` directory exists
-2. Load an agent in your AI tool
-3. Run `/workflow-init`  which will autocomplete to the full command to see available commands
-
-## Configuration
-
-Edit `_bmad/[module]/config.yaml` to customize. For example these could be changed:
-
-```yaml
-output_folder: ./_bmad-output
-user_name: Your Name
-communication_language: english
-```
-
-## Troubleshooting
-
-**"Command not found: npx"** — Install Node.js 20+:
-```bash
-brew install node
-```
-
-**"Permission denied"** — Check npm permissions:
-```bash
-npm config set prefix ~/.npm-global
-```
-
-**Installer hangs** — Try running with verbose output:
-```bash
-npx bmad-method install --verbose
-```

docs/index.md

@@ -10,16 +10,10 @@ If you're comfortable working with AI coding assistants like Claude, Cursor, or
 
 ## New Here? Start with a Tutorial
 
-The fastest way to understand BMad is to try it. Choose a tutorial to walk through your first project in about 10 minutes.
+The fastest way to understand BMad is to try it.
 
-- **[Get Started with BMad](/docs/tutorials/getting-started/getting-started-bmadv6.md)** — Latest features, still in active development
+- **[Get Started with BMad](/docs/tutorials/getting-started.md)** — Install and understand how BMad works
-- **[Workflow Guide](/workflow-guide)** — A simple visual overview of the various BMad tracks that get you going quickly.
+- **[Workflow Map](/docs/reference/workflow-map.md)** — Visual overview of BMM phases, workflows, and context management.
-
-:::tip[Already familiar with AI-assisted development?]
-Feel free to skip around. Use the sidebar to jump to any topic, or check out [What Are Agents?](/docs/explanation/core-concepts/what-are-agents.md) to understand how BMad organizes its AI personas.
-:::
-
----
 
 ## How to Use These Docs
 
@@ -59,6 +53,4 @@ Get help, share what you're building, or contribute to BMad:
 
 ## Next Step
 
-Ready to dive in? Pick a tutorial and start building.
+Ready to dive in? **[Get Started with BMad](/docs/tutorials/getting-started.md)** and build your first project.
-
-- **[Get Started with BMad](/docs/tutorials/getting-started/getting-started-bmadv6.md)** — Explore the latest features

docs/reference/workflow-map.md

@@ -0,0 +1,74 @@
+---
+title: "Workflow Map"
+description: Visual reference for BMad Method workflow phases and outputs
+---
+
+BMAD is a context management system. AI agents work best with clear, structured context. The BMM workflow builds that context progressively - each phase produces documents that inform the next, so agents always know what to build and why.
+
+![BMad Method Workflow Map](/img/workflow-map.png)
+
+## Phase 1: Analysis (Optional)
+
+Explore the problem space and validate ideas before committing to planning.
+
+| Workflow | Purpose | Produces |
+|----------|---------|----------|
+| `research` | Validate market, technical, or domain assumptions | Research findings |
+| `create-product-brief` | Capture strategic vision | `product-brief.md` |
+
+## Phase 2: Planning
+
+Define what to build and for whom.
+
+| Workflow | Purpose | Produces |
+|----------|---------|----------|
+| `prd` | Define requirements (FRs/NFRs) | `PRD.md` |
+| `create-ux-design` | Design user experience (when UX matters) | `ux-spec.md` |
+
+## Phase 3: Solutioning
+
+Decide how to build it and break work into stories.
+
+| Workflow | Purpose | Produces |
+|----------|---------|----------|
+| `create-architecture` | Make technical decisions explicit | `architecture.md` with ADRs |
+| `create-epics-and-stories` | Break requirements into implementable work | Epic files with stories |
+| `check-implementation-readiness` | Gate check before implementation | PASS/CONCERNS/FAIL decision |
+
+## Phase 4: Implementation
+
+Build it, one story at a time.
+
+| Workflow | Purpose | Produces |
+|----------|---------|----------|
+| `sprint-planning` | Initialize tracking (once per project) | `sprint-status.yaml` |
+| `create-story` | Prepare next story for implementation | `story-[slug].md` |
+| `dev-story` | Implement the story | Working code + tests |
+| `code-review` | Validate implementation quality | Approved or changes requested |
+| `correct-course` | Handle significant mid-sprint changes | Updated plan or re-routing |
+| `retrospective` | Review after epic completion | Lessons learned |
+
+## Quick Flow (Parallel Track)
+
+Skip phases 1-3 for small, well-understood work.
+
+| Workflow | Purpose | Produces |
+|----------|---------|----------|
+| `quick-spec` | Define an ad-hoc change | `tech-spec.md` (story file for small changes) |
+| `quick-dev` | Implement from spec or direct instructions | Working code + tests |
+
+## Context Management
+
+Each document becomes context for the next phase. The PRD tells the architect what constraints matter. The architecture tells the dev agent which patterns to follow. Story files give focused, complete context for implementation. Without this structure, agents make inconsistent decisions.
+
+For brownfield projects, `document-project` creates or updates `project-context.md` - what exists in the codebase and the rules all implementation workflows must observe. Run it just before Phase 4, and again when something significant changes - structure, architecture, or those rules. You can also edit `project-context.md` by hand.
+
+All implementation workflows load `project-context.md` if it exists. Additional context per workflow:
+
+| Workflow | Also Loads |
+|----------|------------|
+| `create-story` | epics, PRD, architecture, UX |
+| `dev-story` | story file |
+| `code-review` | architecture, story file |
+| `quick-spec` | planning docs (if exist) |
+| `quick-dev` | tech-spec |

docs/tea/explanation/engagement-models.md

@@ -13,7 +13,7 @@ TEA is optional and flexible. There are five valid ways to engage with TEA - cho
 
 1. **No TEA** - Skip all TEA workflows, use existing testing approach
 2. **TEA Solo** - Use TEA standalone without BMad Method
-3. **TEA Lite** - Beginner approach using just `*automate`
+3. **TEA Lite** - Beginner approach using just `automate`
 4. **TEA Integrated (Greenfield)** - Full BMad Method integration from scratch
 5. **TEA Integrated (Brownfield)** - Full BMad Method integration with existing code
 
@@ -84,10 +84,10 @@ Decision: Skip TEA, keep what works
 
 **Typical Sequence:**
 ```
-1. *test-design (system or epic)
+1. `test-design` (system or epic)
-2. *atdd or *automate
+2. `atdd` or `automate`
-3. *test-review (optional)
+3. `test-review` (optional)
-4. *trace (coverage + gate decision)
+4. `trace` (coverage + gate decision)
 ```
 
 **You Bring:**
@@ -96,14 +96,14 @@ Decision: Skip TEA, keep what works
 - Project context
 
 **TEA Provides:**
-- Risk-based test planning (`*test-design`)
+- Risk-based test planning (`test-design`)
-- Test generation (`*atdd`, `*automate`)
+- Test generation (`atdd`, `automate`)
-- Quality review (`*test-review`)
+- Quality review (`test-review`)
-- Coverage traceability (`*trace`)
+- Coverage traceability (`trace`)
 
 **Optional:**
-- Framework setup (`*framework`) if needed
+- Framework setup (`framework`) if needed
-- CI configuration (`*ci`) if needed
+- CI configuration (`ci`) if needed
 
 **Example:**
 ```
@@ -114,10 +114,10 @@ Your project:
 
 Workflow:
 1. Export stories from Jira
-2. Run *test-design on epic
+2. Run `test-design` on epic
-3. Run *atdd for each story
+3. Run `atdd` for each story
 4. Implement features
-5. Run *trace for coverage
+5. Run `trace` for coverage
 ```
 
 **Verdict:** Best for teams wanting TEA benefits without BMad Method commitment.
@@ -126,7 +126,7 @@ Workflow:
 
 ### Model 3: TEA Lite
 
-**What:** Beginner approach using just `*automate` to test existing features.
+**What:** Beginner approach using just `automate` to test existing features.
 
 **When to Use:**
 - Learning TEA fundamentals
@@ -136,9 +136,9 @@ Workflow:
 
 **Workflow:**
 ```
-1. *framework (setup test infrastructure)
+1. `framework` (setup test infrastructure)
-2. *test-design (optional, risk assessment)
+2. `test-design` (optional, risk assessment)
-3. *automate (generate tests for existing features)
+3. `automate` (generate tests for existing features)
 4. Run tests (they pass immediately)
 ```
 
@@ -150,8 +150,8 @@ Beginner developer:
 - 30 minutes available
 
 Steps:
-1. Run *framework
+1. Run `framework`
-2. Run *automate on TodoMVC demo
+2. Run `automate` on TodoMVC demo
 3. Tests generated and passing
 4. Learn TEA basics
 ```
@@ -186,29 +186,29 @@ Steps:
 
 **Phase 2: Planning**
 - PM creates PRD with NFRs
-- (Optional) TEA runs `*nfr-assess` (Enterprise only)
+- (Optional) TEA runs `nfr-assess` (Enterprise only)
 
 **Phase 3: Solutioning**
 - Architect creates architecture
-- TEA runs `*test-design` (system-level) → testability review
+- TEA runs `test-design` (system-level) → testability review
-- TEA runs `*framework` → test infrastructure
+- TEA runs `framework` → test infrastructure
-- TEA runs `*ci` → CI/CD pipeline
+- TEA runs `ci` → CI/CD pipeline
-- Architect runs `*implementation-readiness` (fed by test design)
+- Architect runs `implementation-readiness` (fed by test design)
 
 **Phase 4: Implementation (Per Epic)**
-- SM runs `*sprint-planning`
+- SM runs `sprint-planning`
-- TEA runs `*test-design` (epic-level) → risk assessment for THIS epic
+- TEA runs `test-design` (epic-level) → risk assessment for THIS epic
 - SM creates stories
-- (Optional) TEA runs `*atdd` → failing tests before dev
+- (Optional) TEA runs `atdd` → failing tests before dev
 - DEV implements story
-- TEA runs `*automate` → expand coverage
+- TEA runs `automate` → expand coverage
-- (Optional) TEA runs `*test-review` → quality audit
+- (Optional) TEA runs `test-review` → quality audit
-- TEA runs `*trace` Phase 1 → refresh coverage
+- TEA runs `trace` Phase 1 → refresh coverage
 
 **Release Gate:**
-- (Optional) TEA runs `*test-review` → final audit
+- (Optional) TEA runs `test-review` → final audit
-- (Optional) TEA runs `*nfr-assess` → validate NFRs
+- (Optional) TEA runs `nfr-assess` → validate NFRs
-- TEA runs `*trace` Phase 2 → gate decision (PASS/CONCERNS/FAIL/WAIVED)
+- TEA runs `trace` Phase 2 → gate decision (PASS/CONCERNS/FAIL/WAIVED)
 
 **What You Get:**
 - Complete quality operating model
@@ -249,30 +249,30 @@ Workflow:
 
 **Phase 0: Documentation (if needed)**
 ```
-- Run *document-project
+- Run `document-project`
 - Create baseline documentation
 ```
 
 **Phase 2: Planning**
 ```
-- TEA runs *trace Phase 1 → establish coverage baseline
+- TEA runs `trace` Phase 1 → establish coverage baseline
 - PM creates PRD (with existing system context)
 ```
 
 **Phase 3: Solutioning**
 ```
 - Architect creates architecture (with brownfield constraints)
-- TEA runs *test-design (system-level) → testability review
+- TEA runs `test-design` (system-level) → testability review
-- TEA runs *framework (only if modernizing test infra)
+- TEA runs `framework` (only if modernizing test infra)
-- TEA runs *ci (update existing CI or create new)
+- TEA runs `ci` (update existing CI or create new)
 ```
 
 **Phase 4: Implementation**
 ```
-- TEA runs *test-design (epic-level) → focus on REGRESSION HOTSPOTS
+- TEA runs `test-design` (epic-level) → focus on REGRESSION HOTSPOTS
 - Per story: ATDD → dev → automate
-- TEA runs *test-review → improve legacy test quality
+- TEA runs `test-review` → improve legacy test quality
-- TEA runs *trace Phase 1 → track coverage improvement
+- TEA runs `trace` Phase 1 → track coverage improvement
 ```
 
 **Brownfield-Specific:**
@@ -289,10 +289,10 @@ Legacy e-commerce platform:
 - Want to improve quality
 
 Workflow:
-1. Phase 2: *trace baseline → 30% coverage
+1. Phase 2: `trace` baseline → 30% coverage
-2. Phase 3: *test-design → identify regression risks
+2. Phase 3: `test-design` → identify regression risks
 3. Phase 4: Fix top 20 flaky tests + add tests for new checkout
-4. Gate: *trace → 60% coverage (2x improvement)
+4. Gate: `trace` → 60% coverage (2x improvement)
 ```
 
 **Verdict:** Best for incrementally improving legacy systems.
@@ -309,7 +309,7 @@ flowchart TD
     Start([Choose TEA Model]) --> BMad{Using<br/>BMad Method?}
 
     BMad -->|No| NonBMad{Project Type?}
-    NonBMad -->|Learning| Lite[TEA Lite<br/>Just *automate<br/>30 min tutorial]
+    NonBMad -->|Learning| Lite[TEA Lite<br/>Just automate<br/>30 min tutorial]
     NonBMad -->|Serious Project| Solo[TEA Solo<br/>Standalone workflows<br/>Full capabilities]
 
     BMad -->|Yes| WantTEA{Want TEA?}
@@ -374,18 +374,18 @@ flowchart TD
 
 ```
 Week 1: TEA Lite
-- Run *framework
+- Run `framework`
-- Run *automate
+- Run `automate`
 - Learn basics
 
 Week 2: Expand to TEA Solo
-- Add *test-design
+- Add `test-design`
-- Use *atdd for new features
+- Use `atdd` for new features
-- Add *test-review
+- Add `test-review`
 
 Week 3: Continue expanding
-- Add *trace for coverage
+- Add `trace` for coverage
-- Setup *ci
+- Setup `ci`
 - Full TEA Solo workflow
 ```
 
@@ -435,8 +435,8 @@ Testing: Manual only
 Decision: Start with TEA Lite
 
 Result:
-- Run *framework (Playwright setup)
+- Run `framework` (Playwright setup)
-- Run *automate (20 tests generated)
+- Run `automate` (20 tests generated)
 - Learning TEA basics
 ```
 
@@ -447,9 +447,9 @@ Testing: Automated tests exist
 Decision: Expand to TEA Solo
 
 Result:
-- Add *test-design (risk assessment)
+- Add `test-design` (risk assessment)
-- Add *atdd (TDD workflow)
+- Add `atdd` (TDD workflow)
-- Add *test-review (quality audits)
+- Add `test-review` (quality audits)
 ```
 
 **Month 6:** TEA Integrated
@@ -477,26 +477,26 @@ Result:
 
 **Phase 2:**
 ```
-- *trace baseline → 45% coverage (lots of gaps)
+- `trace` baseline → 45% coverage (lots of gaps)
 - Document current state
 ```
 
 **Phase 3:**
 ```
-- *test-design (system) → identify regression hotspots
+- `test-design` (system) → identify regression hotspots
-- *framework → modernize test infrastructure
+- `framework` → modernize test infrastructure
-- *ci → add selective testing
+- `ci` → add selective testing
 ```
 
 **Phase 4:**
 ```
 Per epic:
-- *test-design → focus on regression + new features
+- `test-design` → focus on regression + new features
 - Fix top 10 flaky tests
-- *atdd for new features
+- `atdd` for new features
-- *automate for coverage expansion
+- `automate` for coverage expansion
-- *test-review → track quality improvement
+- `test-review` → track quality improvement
-- *trace → compare to baseline
+- `trace` → compare to baseline
 ```
 
 **Result after 6 months:**
@@ -520,9 +520,9 @@ Per epic:
 ```
 Client project 1 (Scrum):
 - Import Jira stories
-- Run *test-design
+- Run `test-design`
-- Generate tests with *atdd/*automate
+- Generate tests with `atdd`/`automate`
-- Deliver quality report with *test-review
+- Deliver quality report with `test-review`
 
 Client project 2 (Kanban):
 - Import requirements from Notion
@@ -581,11 +581,11 @@ Client project 3 (Ad-hoc):
 **When:** Outgrow beginner approach, need more workflows.
 
 **Steps:**
-1. Continue using `*framework` and `*automate`
+1. Continue using `framework` and `automate`
-2. Add `*test-design` for planning
+2. Add `test-design` for planning
-3. Add `*atdd` for TDD workflow
+3. Add `atdd` for TDD workflow
-4. Add `*test-review` for quality audits
+4. Add `test-review` for quality audits
-5. Add `*trace` for coverage tracking
+5. Add `trace` for coverage tracking
 
 **Timeline:** 2-4 weeks of gradual expansion
 
@@ -620,13 +620,13 @@ Client project 3 (Ad-hoc):
 
 ```
 Phase 1 (Week 1-2): TEA Lite
-- Learn with *automate on demo app
+- Learn with `automate` on demo app
 - Understand TEA fundamentals
 - Low commitment
 
 Phase 2 (Week 3-4): Evaluate
-- Try *test-design (planning)
+- Try `test-design` (planning)
-- Try *atdd (TDD)
+- Try `atdd` (TDD)
 - See if value justifies investment
 
 Phase 3 (Month 2+): Decide
@@ -664,46 +664,46 @@ Non-critical features (UI tweaks):
 ## Technical Implementation
 
 Each model uses different TEA workflows. See:
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Model details
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Model details
-- [TEA Command Reference](/docs/reference/tea/commands.md) - Workflow reference
+- [TEA Command Reference](/docs/tea/reference/commands.md) - Workflow reference
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Setup options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Setup options
 
 ## Related Concepts
 
 **Core TEA Concepts:**
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Risk assessment in different models
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Risk assessment in different models
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Quality across all models
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Quality across all models
-- [Knowledge Base System](/docs/explanation/tea/knowledge-base-system.md) - Consistent patterns across models
+- [Knowledge Base System](/docs/tea/explanation/knowledge-base-system.md) - Consistent patterns across models
 
 **Technical Patterns:**
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Infrastructure in different models
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Infrastructure in different models
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Reliability in all models
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Reliability in all models
 
 **Overview:**
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - 5 engagement models with cheat sheets
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - 5 engagement models with cheat sheets
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - Design philosophy
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - Design philosophy
 
 ## Practical Guides
 
 **Getting Started:**
-- [TEA Lite Quickstart Tutorial](/docs/tutorials/getting-started/tea-lite-quickstart.md) - Model 3: TEA Lite
+- [TEA Lite Quickstart Tutorial](/docs/tea/tutorials/tea-lite-quickstart.md) - Model 3: TEA Lite
 
 **Use-Case Guides:**
-- [Using TEA with Existing Tests](/docs/how-to/brownfield/use-tea-with-existing-tests.md) - Model 5: Brownfield
+- [Using TEA with Existing Tests](/docs/tea/how-to/brownfield/use-tea-with-existing-tests.md) - Model 5: Brownfield
-- [Running TEA for Enterprise](/docs/how-to/brownfield/use-tea-for-enterprise.md) - Enterprise integration
+- [Running TEA for Enterprise](/docs/tea/how-to/brownfield/use-tea-for-enterprise.md) - Enterprise integration
 
 **All Workflow Guides:**
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md) - Used in TEA Solo and Integrated
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md) - Used in TEA Solo and Integrated
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md)
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md)
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md)
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md)
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md)
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md)
-- [How to Run Trace](/docs/how-to/workflows/run-trace.md)
+- [How to Run Trace](/docs/tea/how-to/workflows/run-trace.md)
 
 ## Reference
 
-- [TEA Command Reference](/docs/reference/tea/commands.md) - All workflows explained
+- [TEA Command Reference](/docs/tea/reference/commands.md) - All workflows explained
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Config per model
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Config per model
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - TEA Lite, TEA Solo, TEA Integrated terms
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - TEA Lite, TEA Solo, TEA Integrated terms
 
 ---
 

docs/tea/explanation/fixture-architecture.md

@@ -232,7 +232,7 @@ test('should update profile', async ({ apiRequest, authToken, log }) => {
 });
 ```
 
-**Note:** This example uses the vanilla pure function signature (`url`, `data`). Playwright Utils uses different parameter names (`path`, `body`). See [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) for the utilities API.
+**Note:** This example uses the vanilla pure function signature (`url`, `data`). Playwright Utils uses different parameter names (`path`, `body`). See [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) for the utilities API.
 
 **Note:** `authToken` requires auth-session fixture setup with provider configuration. See [auth-session documentation](https://seontechnologies.github.io/playwright-utils/auth-session.html).
 
@@ -246,7 +246,7 @@ test('should update profile', async ({ apiRequest, authToken, log }) => {
 
 ### TEA Generates This Pattern
 
-When you run `*framework` with `tea_use_playwright_utils: true`:
+When you run `framework` with `tea_use_playwright_utils: true`:
 
 **TEA scaffolds:**
 ```
@@ -265,7 +265,7 @@ tests/
 
 ### TEA Reviews Against This Pattern
 
-When you run `*test-review`:
+When you run `test-review`:
 
 **TEA checks:**
 - Are utilities pure functions? ✓
@@ -385,8 +385,8 @@ export const test = mergeTests(apiRequestTest, authSessionTest, logTest);
 ## Technical Implementation
 
 For detailed fixture architecture patterns, see the knowledge base:
-- [Knowledge Base Index - Architecture & Fixtures](/docs/reference/tea/knowledge-base.md)
+- [Knowledge Base Index - Architecture & Fixtures](/docs/tea/reference/knowledge-base.md)
-- [Complete Knowledge Base Index](/docs/reference/tea/knowledge-base.md)
+- [Complete Knowledge Base Index](/docs/tea/reference/knowledge-base.md)
 
 ## When to Use This Pattern
 
@@ -425,32 +425,32 @@ function createTestUser(name: string) {
 ## Related Concepts
 
 **Core TEA Concepts:**
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Quality standards fixtures enforce
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Quality standards fixtures enforce
-- [Knowledge Base System](/docs/explanation/tea/knowledge-base-system.md) - Fixture patterns in knowledge base
+- [Knowledge Base System](/docs/tea/explanation/knowledge-base-system.md) - Fixture patterns in knowledge base
 
 **Technical Patterns:**
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Network fixtures explained
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Network fixtures explained
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Fixture complexity matches risk
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Fixture complexity matches risk
 
 **Overview:**
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Fixture architecture in workflows
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Fixture architecture in workflows
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - Why fixtures matter
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - Why fixtures matter
 
 ## Practical Guides
 
 **Setup Guides:**
-- [How to Set Up Test Framework](/docs/how-to/workflows/setup-test-framework.md) - TEA scaffolds fixtures
+- [How to Set Up Test Framework](/docs/tea/how-to/workflows/setup-test-framework.md) - TEA scaffolds fixtures
-- [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) - Production-ready fixtures
+- [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) - Production-ready fixtures
 
 **Workflow Guides:**
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) - Using fixtures in tests
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md) - Using fixtures in tests
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Fixture composition examples
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md) - Fixture composition examples
 
 ## Reference
 
-- [TEA Command Reference](/docs/reference/tea/commands.md) - *framework command
+- [TEA Command Reference](/docs/tea/reference/commands.md) - `framework` command
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Fixture architecture fragments
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Fixture architecture fragments
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - Fixture architecture term
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - Fixture architecture term
 
 ---
 

docs/tea/explanation/knowledge-base-system.md

@@ -91,7 +91,7 @@ fixture-architecture,Fixture Architecture,Composable fixture patterns,fixtures;a
 
 **2. Workflow Loads Relevant Fragments**
 
-When user runs `*atdd`:
+When user runs `atdd`:
 ```
 TEA reads tea-index.csv
 Identifies fragments needed for ATDD:
@@ -107,7 +107,7 @@ Generates tests following these patterns
 
 **3. Consistent Output**
 
-Every time `*atdd` runs:
+Every time `atdd` runs:
 - Same fragments loaded
 - Same patterns applied
 - Same quality standards
@@ -120,7 +120,7 @@ Every time `*atdd` runs:
 ```mermaid
 %%{init: {'theme':'base', 'themeVariables': { 'fontSize':'14px'}}}%%
 flowchart TD
-    User([User: *atdd]) --> Workflow[TEA Workflow<br/>Triggered]
+    User([User: atdd]) --> Workflow[TEA Workflow<br/>Triggered]
     Workflow --> Read[Read Manifest<br/>tea-index.csv]
 
     Read --> Identify{Identify Relevant<br/>Fragments for ATDD}
@@ -257,12 +257,12 @@ await page.waitForTimeout(3000);
 
 | Workflow | Fragments Loaded | Purpose |
 |----------|-----------------|---------|
-| `*framework` | fixture-architecture, playwright-config, fixtures-composition | Infrastructure patterns |
+| `framework` | fixture-architecture, playwright-config, fixtures-composition | Infrastructure patterns |
-| `*test-design` | test-quality, test-priorities-matrix, risk-governance | Planning standards |
+| `test-design` | test-quality, test-priorities-matrix, risk-governance | Planning standards |
-| `*atdd` | test-quality, component-tdd, network-first, data-factories | TDD patterns |
+| `atdd` | test-quality, component-tdd, network-first, data-factories | TDD patterns |
-| `*automate` | test-quality, test-levels-framework, selector-resilience | Comprehensive generation |
+| `automate` | test-quality, test-levels-framework, selector-resilience | Comprehensive generation |
-| `*test-review` | All quality/resilience/debugging fragments | Full audit patterns |
+| `test-review` | All quality/resilience/debugging fragments | Full audit patterns |
-| `*ci` | ci-burn-in, burn-in, selective-testing | CI/CD optimization |
+| `ci` | ci-burn-in, burn-in, selective-testing | CI/CD optimization |
 
 **Benefit:** Only load what's needed (focused context, no bloat).
 
@@ -271,7 +271,7 @@ await page.waitForTimeout(3000);
 TEA doesn't load all 33 fragments at once:
 
 ```
-User runs: *atdd for authentication feature
+User runs: atdd for authentication feature
 
 TEA analyzes context:
 - Feature type: Authentication
@@ -298,7 +298,7 @@ Result: 5 relevant fragments loaded, 28 skipped
 
 **Without Knowledge Base (Vanilla Playwright, Random Quality):**
 ```
-Session 1: User runs *atdd
+Session 1: User runs atdd
 AI: [Guesses patterns from general knowledge]
 
 Generated:
@@ -309,7 +309,7 @@ test('api test', async ({ request }) => {
   // Random quality
 });
 
-Session 2: User runs *atdd (different day)
+Session 2: User runs atdd (different day)
 AI: [Different random patterns]
 
 Generated:
@@ -324,7 +324,7 @@ Result: Inconsistent quality, random patterns
 
 **With Knowledge Base (TEA + Playwright Utils):**
 ```
-Session 1: User runs *atdd
+Session 1: User runs atdd
 TEA: [Loads test-quality.md, network-first.md, api-request.md from tea-index.csv]
 
 Generated:
@@ -340,7 +340,7 @@ test('should fetch users', async ({ apiRequest }) => {
   expect(body).toBeInstanceOf(Array);
 });
 
-Session 2: User runs *atdd (different day)
+Session 2: User runs atdd (different day)
 TEA: [Loads same fragments from tea-index.csv]
 
 Generated: Identical pattern, same quality
@@ -356,10 +356,10 @@ Result: Systematic quality, established patterns (ALWAYS uses apiRequest utility
 
 **Without Knowledge Base:**
 ```
-*test-review session 1:
+test-review session 1:
 "This test looks okay" [50 issues missed]
 
-*test-review session 2:
+test-review session 2:
 "This test has some issues" [Different issues flagged]
 
 Result: Inconsistent feedback
@@ -367,11 +367,11 @@ Result: Inconsistent feedback
 
 **With Knowledge Base:**
 ```
-*test-review session 1:
+test-review session 1:
 [Loads all quality fragments]
 Flags: 12 hard waits, 5 conditionals (based on test-quality.md)
 
-*test-review session 2:
+test-review session 2:
 [Loads same fragments]
 Flags: Same issues with same explanations
 
@@ -430,12 +430,12 @@ Result: Consistent, reliable feedback
 ### 2. Onboarding
 
 **Before:** New team member reads 20 documents, asks 50 questions
-**After:** New team member runs `*atdd`, sees patterns in generated code, learns by example
+**After:** New team member runs `atdd`, sees patterns in generated code, learns by example
 
 ### 3. Quality Gates
 
 **Before:** "Is this test good?" → subjective opinion
-**After:** "*test-review" → objective score against knowledge base
+**After:** `test-review` → objective score against knowledge base
 
 ### 4. Pattern Evolution
 
@@ -513,41 +513,41 @@ test('job completion', async ({ apiRequest, recurse }) => {
 ## Technical Implementation
 
 For details on the knowledge base index, see:
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md)
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md)
-- [TEA Configuration](/docs/reference/tea/configuration.md)
+- [TEA Configuration](/docs/tea/reference/configuration.md)
 
 ## Related Concepts
 
 **Core TEA Concepts:**
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Standards in knowledge base
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Standards in knowledge base
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Risk patterns in knowledge base
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Risk patterns in knowledge base
-- [Engagement Models](/docs/explanation/tea/engagement-models.md) - Knowledge base across all models
+- [Engagement Models](/docs/tea/explanation/engagement-models.md) - Knowledge base across all models
 
 **Technical Patterns:**
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Fixture patterns in knowledge base
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Fixture patterns in knowledge base
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Network patterns in knowledge base
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Network patterns in knowledge base
 
 **Overview:**
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Knowledge base in workflows
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Knowledge base in workflows
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - **Foundation: Context engineering philosophy** (why knowledge base solves AI test problems)
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - **Foundation: Context engineering philosophy** (why knowledge base solves AI test problems)
 
 ## Practical Guides
 
 **All Workflow Guides Use Knowledge Base:**
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md)
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md)
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md)
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md)
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md)
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md)
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md)
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md)
 
 **Integration:**
-- [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) - PW-Utils in knowledge base
+- [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) - PW-Utils in knowledge base
 
 ## Reference
 
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Complete fragment index
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Complete fragment index
-- [TEA Command Reference](/docs/reference/tea/commands.md) - Which workflows load which fragments
+- [TEA Command Reference](/docs/tea/reference/commands.md) - Which workflows load which fragments
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Config affects fragment loading
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Config affects fragment loading
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - Context engineering, knowledge fragment terms
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - Context engineering, knowledge fragment terms
 
 ---
 

docs/tea/explanation/network-first-patterns.md

@@ -232,7 +232,7 @@ sequenceDiagram
 
 **Vanilla Playwright:**
 ```typescript
-// When you run *atdd or *automate, TEA generates:
+// When you run `atdd` or `automate`, TEA generates:
 
 test('should create user', async ({ page }) => {
   // TEA automatically includes network wait
@@ -287,7 +287,7 @@ test('should create user', async ({ page, interceptNetworkCall }) => {
 
 ### TEA Reviews for Hard Waits
 
-When you run `*test-review`:
+When you run `test-review`:
 
 ```markdown
 ## Critical Issue: Hard Wait Detected
@@ -807,46 +807,46 @@ test('test 2', async ({ page, interceptNetworkCall }) => {
 - Glob pattern matching (`**/api/**`)
 - Consistent API across all tests
 
-See [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md#intercept-network-call) for setup.
+See [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md#intercept-network-call) for setup.
 
 ## Technical Implementation
 
 For detailed network-first patterns, see the knowledge base:
-- [Knowledge Base Index - Network & Reliability](/docs/reference/tea/knowledge-base.md)
+- [Knowledge Base Index - Network & Reliability](/docs/tea/reference/knowledge-base.md)
-- [Complete Knowledge Base Index](/docs/reference/tea/knowledge-base.md)
+- [Complete Knowledge Base Index](/docs/tea/reference/knowledge-base.md)
 
 ## Related Concepts
 
 **Core TEA Concepts:**
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Determinism requires network-first
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Determinism requires network-first
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - High-risk features need reliable tests
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - High-risk features need reliable tests
 
 **Technical Patterns:**
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Network utilities as fixtures
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Network utilities as fixtures
-- [Knowledge Base System](/docs/explanation/tea/knowledge-base-system.md) - Network patterns in knowledge base
+- [Knowledge Base System](/docs/tea/explanation/knowledge-base-system.md) - Network patterns in knowledge base
 
 **Overview:**
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Network-first in workflows
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Network-first in workflows
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - Why flakiness matters
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - Why flakiness matters
 
 ## Practical Guides
 
 **Workflow Guides:**
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md) - Review for hard waits
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md) - Review for hard waits
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) - Generate network-first tests
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md) - Generate network-first tests
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Expand with network patterns
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md) - Expand with network patterns
 
 **Use-Case Guides:**
-- [Using TEA with Existing Tests](/docs/how-to/brownfield/use-tea-with-existing-tests.md) - Fix flaky legacy tests
+- [Using TEA with Existing Tests](/docs/tea/how-to/brownfield/use-tea-with-existing-tests.md) - Fix flaky legacy tests
 
 **Customization:**
-- [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) - Network utilities (recorder, interceptor, error monitor)
+- [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) - Network utilities (recorder, interceptor, error monitor)
 
 ## Reference
 
-- [TEA Command Reference](/docs/reference/tea/commands.md) - All workflows use network-first
+- [TEA Command Reference](/docs/tea/reference/commands.md) - All workflows use network-first
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Network-first fragment
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Network-first fragment
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - Network-first pattern term
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - Network-first pattern term
 
 ---
 

docs/tea/explanation/risk-based-testing.md

@@ -250,7 +250,7 @@ Risk scores inform test priorities (but aren't the only factor):
 - **Test Levels:** E2E smoke test only
 - **Example:** Theme customization, experimental features
 
-**Note:** Priorities consider risk scores plus business context (usage frequency, user impact, etc.). See [Test Priorities Matrix](/docs/reference/tea/knowledge-base.md#quality-standards) for complete criteria.
+**Note:** Priorities consider risk scores plus business context (usage frequency, user impact, etc.). See [Test Priorities Matrix](/docs/tea/reference/knowledge-base.md#quality-standards) for complete criteria.
 
 ### 3. Mitigation Plans
 
@@ -459,12 +459,12 @@ describe('User profile - High Value (P1)', () => {
 ## Technical Implementation
 
 For detailed risk governance patterns, see the knowledge base:
-- [Knowledge Base Index - Risk & Gates](/docs/reference/tea/knowledge-base.md)
+- [Knowledge Base Index - Risk & Gates](/docs/tea/reference/knowledge-base.md)
-- [TEA Command Reference - *test-design](/docs/reference/tea/commands.md#test-design)
+- [TEA Command Reference - `test-design`](/docs/tea/reference/commands.md#test-design)
 
 ### Risk Scoring Matrix
 
-TEA uses this framework in `*test-design`:
+TEA uses this framework in `test-design`:
 
 ```
            Impact
@@ -553,33 +553,33 @@ flowchart TD
 ## Related Concepts
 
 **Core TEA Concepts:**
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Quality complements risk assessment
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Quality complements risk assessment
-- [Engagement Models](/docs/explanation/tea/engagement-models.md) - When risk-based testing matters most
+- [Engagement Models](/docs/tea/explanation/engagement-models.md) - When risk-based testing matters most
-- [Knowledge Base System](/docs/explanation/tea/knowledge-base-system.md) - How risk patterns are loaded
+- [Knowledge Base System](/docs/tea/explanation/knowledge-base-system.md) - How risk patterns are loaded
 
 **Technical Patterns:**
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Building risk-appropriate test infrastructure
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Building risk-appropriate test infrastructure
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Quality patterns for high-risk features
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Quality patterns for high-risk features
 
 **Overview:**
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Risk assessment in TEA lifecycle
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Risk assessment in TEA lifecycle
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - Design philosophy
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - Design philosophy
 
 ## Practical Guides
 
 **Workflow Guides:**
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md) - Apply risk scoring
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md) - Apply risk scoring
-- [How to Run Trace](/docs/how-to/workflows/run-trace.md) - Gate decisions based on risk
+- [How to Run Trace](/docs/tea/how-to/workflows/run-trace.md) - Gate decisions based on risk
-- [How to Run NFR Assessment](/docs/how-to/workflows/run-nfr-assess.md) - NFR risk assessment
+- [How to Run NFR Assessment](/docs/tea/how-to/workflows/run-nfr-assess.md) - NFR risk assessment
 
 **Use-Case Guides:**
-- [Running TEA for Enterprise](/docs/how-to/brownfield/use-tea-for-enterprise.md) - Enterprise risk management
+- [Running TEA for Enterprise](/docs/tea/how-to/brownfield/use-tea-for-enterprise.md) - Enterprise risk management
 
 ## Reference
 
-- [TEA Command Reference](/docs/reference/tea/commands.md) - `*test-design`, `*nfr-assess`, `*trace`
+- [TEA Command Reference](/docs/tea/reference/commands.md) - `test-design`, `nfr-assess`, `trace`
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Risk governance fragments
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Risk governance fragments
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - Risk-based testing term
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - Risk-based testing term
 
 ---
 

docs/tea/explanation/tea-overview.md

@@ -7,7 +7,7 @@ description: Understanding the Test Architect (TEA) agent and its role in BMad M
 The Test Architect (TEA) is a specialized agent focused on quality strategy, test automation, and release gates in BMad Method projects.
 
 :::tip[Design Philosophy]
-TEA was built to solve AI-generated tests that rot in review. For the problem statement and design principles, see [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md). For setup, see [Setup Test Framework](/docs/how-to/workflows/setup-test-framework.md).
+TEA was built to solve AI-generated tests that rot in review. For the problem statement and design principles, see [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md). For setup, see [Setup Test Framework](/docs/tea/how-to/workflows/setup-test-framework.md).
 :::
 
 ## Overview
@@ -25,31 +25,31 @@ BMad does not mandate TEA. There are five valid ways to use it (or skip it). Pic
 
 2. **TEA Solo (Standalone)**
    - Use TEA on a non-BMad project. Bring your own requirements, acceptance criteria, and environments.
-   - Typical sequence: `*test-design` (system or epic) -> `*atdd` and/or `*automate` -> optional `*test-review` -> `*trace` for coverage and gate decisions.
+   - Typical sequence: `test-design` (system or epic) -> `atdd` and/or `automate` -> optional `test-review` -> `trace` for coverage and gate decisions.
-   - Run `*framework` or `*ci` only if you want TEA to scaffold the harness or pipeline; they work best after you decide the stack/architecture.
+   - Run `framework` or `ci` only if you want TEA to scaffold the harness or pipeline; they work best after you decide the stack/architecture.
 
 **TEA Lite (Beginner Approach):**
-   - Simplest way to use TEA - just use `*automate` to test existing features.
+   - Simplest way to use TEA - just use `automate` to test existing features.
    - Perfect for learning TEA fundamentals in 30 minutes.
-   - See [TEA Lite Quickstart Tutorial](/docs/tutorials/getting-started/tea-lite-quickstart.md).
+   - See [TEA Lite Quickstart Tutorial](/docs/tea/tutorials/tea-lite-quickstart.md).
 
 3. **Integrated: Greenfield - BMad Method (Simple/Standard Work)**
-   - Phase 3: system-level `*test-design`, then `*framework` and `*ci`.
+   - Phase 3: system-level `test-design`, then `framework` and `ci`.
-   - Phase 4: per-epic `*test-design`, optional `*atdd`, then `*automate` and optional `*test-review`.
+   - Phase 4: per-epic `test-design`, optional `atdd`, then `automate` and optional `test-review`.
-   - Gate (Phase 2): `*trace`.
+   - Gate (Phase 2): `trace`.
 
 4. **Integrated: Brownfield - BMad Method or Enterprise (Simple or Complex)**
-   - Phase 2: baseline `*trace`.
+   - Phase 2: baseline `trace`.
-   - Phase 3: system-level `*test-design`, then `*framework` and `*ci`.
+   - Phase 3: system-level `test-design`, then `framework` and `ci`.
-   - Phase 4: per-epic `*test-design` focused on regression and integration risks.
+   - Phase 4: per-epic `test-design` focused on regression and integration risks.
-   - Gate (Phase 2): `*trace`; `*nfr-assess` (if not done earlier).
+   - Gate (Phase 2): `trace`; `nfr-assess` (if not done earlier).
-   - For brownfield BMad Method, follow the same flow with `*nfr-assess` optional.
+   - For brownfield BMad Method, follow the same flow with `nfr-assess` optional.
 
 5. **Integrated: Greenfield - Enterprise Method (Enterprise/Compliance Work)**
-   - Phase 2: `*nfr-assess`.
+   - Phase 2: `nfr-assess`.
-   - Phase 3: system-level `*test-design`, then `*framework` and `*ci`.
+   - Phase 3: system-level `test-design`, then `framework` and `ci`.
-   - Phase 4: per-epic `*test-design`, plus `*atdd`/`*automate`/`*test-review`.
+   - Phase 4: per-epic `test-design`, plus `atdd`/`automate`/`test-review`.
-   - Gate (Phase 2): `*trace`; archive artifacts as needed.
+   - Gate (Phase 2): `trace`; archive artifacts as needed.
 
 If you are unsure, default to the integrated path for your track and adjust later.
 
@@ -57,24 +57,24 @@ If you are unsure, default to the integrated path for your track and adjust late
 
 | Command        | Primary Outputs                                                                               | Notes                                                | With Playwright MCP Enhancements                                                                                                     |
 | -------------- | --------------------------------------------------------------------------------------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
-| `*framework`   | Playwright/Cypress scaffold, `.env.example`, `.nvmrc`, sample specs                           | Use when no production-ready harness exists          | -                                                                                                                                    |
+| `framework`    | Playwright/Cypress scaffold, `.env.example`, `.nvmrc`, sample specs                           | Use when no production-ready harness exists          | -                                                                                                                                    |
-| `*ci`          | CI workflow, selective test scripts, secrets checklist                                        | Platform-aware (GitHub Actions default)              | -                                                                                                                                    |
+| `ci`           | CI workflow, selective test scripts, secrets checklist                                        | Platform-aware (GitHub Actions default)              | -                                                                                                                                    |
-| `*test-design` | Combined risk assessment, mitigation plan, and coverage strategy                              | Risk scoring + optional exploratory mode             | **+ Exploratory**: Interactive UI discovery with browser automation (uncover actual functionality)                                   |
+| `test-design`  | Combined risk assessment, mitigation plan, and coverage strategy                              | Risk scoring + optional exploratory mode             | **+ Exploratory**: Interactive UI discovery with browser automation (uncover actual functionality)                                   |
-| `*atdd`        | Failing acceptance tests + implementation checklist                                           | TDD red phase + optional recording mode              | **+ Recording**: UI selectors verified with live browser; API tests benefit from trace analysis                                      |
+| `atdd`         | Failing acceptance tests + implementation checklist                                           | TDD red phase + optional recording mode              | **+ Recording**: UI selectors verified with live browser; API tests benefit from trace analysis                                      |
-| `*automate`    | Prioritized specs, fixtures, README/script updates, DoD summary                               | Optional healing/recording, avoid duplicate coverage | **+ Healing**: Visual debugging + trace analysis for test fixes; **+ Recording**: Verified selectors (UI) + network inspection (API) |
+| `automate`     | Prioritized specs, fixtures, README/script updates, DoD summary                               | Optional healing/recording, avoid duplicate coverage | **+ Healing**: Visual debugging + trace analysis for test fixes; **+ Recording**: Verified selectors (UI) + network inspection (API) |
-| `*test-review` | Test quality review report with 0-100 score, violations, fixes                                | Reviews tests against knowledge base patterns        | -                                                                                                                                    |
+| `test-review`  | Test quality review report with 0-100 score, violations, fixes                                | Reviews tests against knowledge base patterns        | -                                                                                                                                    |
-| `*nfr-assess`  | NFR assessment report with actions                                                            | Focus on security/performance/reliability            | -                                                                                                                                    |
+| `nfr-assess`   | NFR assessment report with actions                                                            | Focus on security/performance/reliability            | -                                                                                                                                    |
-| `*trace`       | Phase 1: Coverage matrix, recommendations. Phase 2: Gate decision (PASS/CONCERNS/FAIL/WAIVED) | Two-phase workflow: traceability + gate decision     | -                                                                                                                                    |
+| `trace`        | Phase 1: Coverage matrix, recommendations. Phase 2: Gate decision (PASS/CONCERNS/FAIL/WAIVED) | Two-phase workflow: traceability + gate decision     | -                                                                                                                                    |
 
 ## TEA Workflow Lifecycle
 
 **Phase Numbering Note:** BMad uses a 4-phase methodology with optional Phase 1 and a documentation prerequisite:
 
-- **Documentation** (Optional for brownfield): Prerequisite using `*document-project`
+- **Documentation** (Optional for brownfield): Prerequisite using `document-project`
-- **Phase 1** (Optional): Discovery/Analysis (`*brainstorm`, `*research`, `*product-brief`)
+- **Phase 1** (Optional): Discovery/Analysis (`brainstorm`, `research`, `product-brief`)
-- **Phase 2** (Required): Planning (`*prd` creates PRD with FRs/NFRs)
+- **Phase 2** (Required): Planning (`prd` creates PRD with FRs/NFRs)
-- **Phase 3** (Track-dependent): Solutioning (`*architecture` → `*test-design` (system-level) → `*create-epics-and-stories` → TEA: `*framework`, `*ci` → `*implementation-readiness`)
+- **Phase 3** (Track-dependent): Solutioning (`architecture` → `test-design` (system-level) → `create-epics-and-stories` → TEA: `framework`, `ci` → `implementation-readiness`)
-- **Phase 4** (Required): Implementation (`*sprint-planning` → per-epic: `*test-design` → per-story: dev workflows)
+- **Phase 4** (Required): Implementation (`sprint-planning` → per-epic: `test-design` → per-story: dev workflows)
 
 TEA integrates into the BMad development lifecycle during Solutioning (Phase 3) and Implementation (Phase 4):
 
@@ -82,21 +82,21 @@ TEA integrates into the BMad development lifecycle during Solutioning (Phase 3)
 %%{init: {'theme':'base', 'themeVariables': { 'primaryColor':'#fff','primaryTextColor':'#000','primaryBorderColor':'#000','lineColor':'#000','secondaryColor':'#fff','tertiaryColor':'#fff','fontSize':'16px','fontFamily':'arial'}}}%%
 graph TB
     subgraph Phase2["<b>Phase 2: PLANNING</b>"]
-        PM["<b>PM: *prd (creates PRD with FRs/NFRs)</b>"]
+        PM["<b>PM: prd (creates PRD with FRs/NFRs)</b>"]
         PlanNote["<b>Business requirements phase</b>"]
-        NFR2["<b>TEA: *nfr-assess (optional, enterprise)</b>"]
+        NFR2["<b>TEA: nfr-assess (optional, enterprise)</b>"]
         PM -.-> NFR2
         NFR2 -.-> PlanNote
         PM -.-> PlanNote
     end
 
     subgraph Phase3["<b>Phase 3: SOLUTIONING</b>"]
-        Architecture["<b>Architect: *architecture</b>"]
+        Architecture["<b>Architect: architecture</b>"]
-        EpicsStories["<b>PM/Architect: *create-epics-and-stories</b>"]
+        EpicsStories["<b>PM/Architect: create-epics-and-stories</b>"]
-        TestDesignSys["<b>TEA: *test-design (system-level)</b>"]
+        TestDesignSys["<b>TEA: test-design (system-level)</b>"]
-        Framework["<b>TEA: *framework (optional if needed)</b>"]
+        Framework["<b>TEA: framework (optional if needed)</b>"]
-        CI["<b>TEA: *ci (optional if needed)</b>"]
+        CI["<b>TEA: ci (optional if needed)</b>"]
-        GateCheck["<b>Architect: *implementation-readiness</b>"]
+        GateCheck["<b>Architect: implementation-readiness</b>"]
         Architecture --> EpicsStories
         Architecture --> TestDesignSys
         TestDesignSys --> Framework
@@ -108,14 +108,14 @@ graph TB
     end
 
     subgraph Phase4["<b>Phase 4: IMPLEMENTATION - Per Epic Cycle</b>"]
-        SprintPlan["<b>SM: *sprint-planning</b>"]
+        SprintPlan["<b>SM: sprint-planning</b>"]
-        TestDesign["<b>TEA: *test-design (per epic)</b>"]
+        TestDesign["<b>TEA: test-design (per epic)</b>"]
-        CreateStory["<b>SM: *create-story</b>"]
+        CreateStory["<b>SM: create-story</b>"]
-        ATDD["<b>TEA: *atdd (optional, before dev)</b>"]
+        ATDD["<b>TEA: atdd (optional, before dev)</b>"]
         DevImpl["<b>DEV: implements story</b>"]
-        Automate["<b>TEA: *automate</b>"]
+        Automate["<b>TEA: automate</b>"]
-        TestReview1["<b>TEA: *test-review (optional)</b>"]
+        TestReview1["<b>TEA: test-review (optional)</b>"]
-        Trace1["<b>TEA: *trace (refresh coverage)</b>"]
+        Trace1["<b>TEA: trace (refresh coverage)</b>"]
 
         SprintPlan --> TestDesign
         TestDesign --> CreateStory
@@ -130,9 +130,9 @@ graph TB
     end
 
     subgraph Gate["<b>EPIC/RELEASE GATE</b>"]
-        NFR["<b>TEA: *nfr-assess (if not done earlier)</b>"]
+        NFR["<b>TEA: nfr-assess (if not done earlier)</b>"]
-        TestReview2["<b>TEA: *test-review (final audit, optional)</b>"]
+        TestReview2["<b>TEA: test-review (final audit, optional)</b>"]
-        TraceGate["<b>TEA: *trace - Phase 2: Gate</b>"]
+        TraceGate["<b>TEA: trace - Phase 2: Gate</b>"]
         GateDecision{"<b>Gate Decision</b>"}
 
         NFR --> TestReview2
@@ -158,14 +158,14 @@ graph TB
     style Waived fill:#9c27b0,stroke:#4a148c,stroke-width:3px,color:#000
 ```
 
-**TEA workflows:** `*framework` and `*ci` run once in Phase 3 after architecture. `*test-design` is **dual-mode**:
+**TEA workflows:** `framework` and `ci` run once in Phase 3 after architecture. `test-design` is **dual-mode**:
 
 - **System-level (Phase 3):** Run immediately after architecture/ADR drafting to produce TWO documents: `test-design-architecture.md` (for Architecture/Dev teams: testability gaps, ASRs, NFR requirements) + `test-design-qa.md` (for QA team: test execution recipe, coverage plan, Sprint 0 setup). Feeds the implementation-readiness gate.
 - **Epic-level (Phase 4):** Run per-epic to produce `test-design-epic-N.md` (risk, priorities, coverage plan).
 
 The Quick Flow track skips Phases 1 and 3.
 BMad Method and Enterprise use all phases based on project needs.
-When an ADR or architecture draft is produced, run `*test-design` in **system-level** mode before the implementation-readiness gate. This ensures the ADR has an attached testability review and ADR → test mapping. Keep the test-design updated if ADRs change.
+When an ADR or architecture draft is produced, run `test-design` in **system-level** mode before the implementation-readiness gate. This ensures the ADR has an attached testability review and ADR → test mapping. Keep the test-design updated if ADRs change.
 
 ## Why TEA Is Different from Other BMM Agents
 
@@ -176,11 +176,11 @@ TEA spans multiple phases (Phase 3, Phase 4, and the release gate). Most BMM age
 | Phase       | TEA Workflows                                             | Frequency        | Purpose                                                 |
 | ----------- | --------------------------------------------------------- | ---------------- | ------------------------------------------------------- |
 | **Phase 2** | (none)                                                    | -                | Planning phase - PM defines requirements                |
-| **Phase 3** | \*test-design (system-level), \*framework, \*ci           | Once per project | System testability review and test infrastructure setup |
+| **Phase 3** | `test-design` (system-level), `framework`, `ci`           | Once per project | System testability review and test infrastructure setup |
-| **Phase 4** | \*test-design, \*atdd, \*automate, \*test-review, \*trace | Per epic/story   | Test planning per epic, then per-story testing          |
+| **Phase 4** | `test-design`, `atdd`, `automate`, `test-review`, `trace` | Per epic/story   | Test planning per epic, then per-story testing          |
-| **Release** | \*nfr-assess, \*trace (Phase 2: gate)                     | Per epic/release | Go/no-go decision                                       |
+| **Release** | `nfr-assess`, `trace` (Phase 2: gate)                     | Per epic/release | Go/no-go decision                                       |
 
-**Note**: `*trace` is a two-phase workflow: Phase 1 (traceability) + Phase 2 (gate decision). This reduces cognitive load while maintaining natural workflow.
+**Note**: `trace` is a two-phase workflow: Phase 1 (traceability) + Phase 2 (gate decision). This reduces cognitive load while maintaining natural workflow.
 
 ### Why TEA Requires Its Own Knowledge Base
 
@@ -211,19 +211,19 @@ These cheat sheets map TEA workflows to the **BMad Method and Enterprise tracks*
 
 | Workflow Stage             | Test Architect                                                    | Dev / Team                                                                          | Outputs                                                    |
 | -------------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ---------------------------------------------------------- |
-| **Phase 1**: Discovery     | -                                                                 | Analyst `*product-brief` (optional)                                                 | `product-brief.md`                                         |
+| **Phase 1**: Discovery     | -                                                                 | Analyst `product-brief` (optional)                                                 | `product-brief.md`                                         |
-| **Phase 2**: Planning      | -                                                                 | PM `*prd` (creates PRD with FRs/NFRs)                                               | PRD with functional/non-functional requirements            |
+| **Phase 2**: Planning      | -                                                                 | PM `prd` (creates PRD with FRs/NFRs)                                               | PRD with functional/non-functional requirements            |
-| **Phase 3**: Solutioning   | Run `*framework`, `*ci` AFTER architecture and epic creation      | Architect `*architecture`, `*create-epics-and-stories`, `*implementation-readiness` | Architecture, epics/stories, test scaffold, CI pipeline    |
+| **Phase 3**: Solutioning   | Run `framework`, `ci` AFTER architecture and epic creation        | Architect `architecture`, `create-epics-and-stories`, `implementation-readiness`   | Architecture, epics/stories, test scaffold, CI pipeline    |
-| **Phase 4**: Sprint Start  | -                                                                 | SM `*sprint-planning`                                                               | Sprint status file with all epics and stories              |
+| **Phase 4**: Sprint Start  | -                                                                 | SM `sprint-planning`                                                               | Sprint status file with all epics and stories              |
-| **Phase 4**: Epic Planning | Run `*test-design` for THIS epic (per-epic test plan)             | Review epic scope                                                                   | `test-design-epic-N.md` with risk assessment and test plan |
+| **Phase 4**: Epic Planning | Run `test-design` for THIS epic (per-epic test plan)              | Review epic scope                                                                  | `test-design-epic-N.md` with risk assessment and test plan |
-| **Phase 4**: Story Dev     | (Optional) `*atdd` before dev, then `*automate` after             | SM `*create-story`, DEV implements                                                  | Tests, story implementation                                |
+| **Phase 4**: Story Dev     | (Optional) `atdd` before dev, then `automate` after               | SM `create-story`, DEV implements                                                  | Tests, story implementation                                |
-| **Phase 4**: Story Review  | Execute `*test-review` (optional), re-run `*trace`                | Address recommendations, update code/tests                                          | Quality report, refreshed coverage matrix                  |
+| **Phase 4**: Story Review  | Execute `test-review` (optional), re-run `trace`                  | Address recommendations, update code/tests                                         | Quality report, refreshed coverage matrix                  |
-| **Phase 4**: Release Gate  | (Optional) `*test-review` for final audit, Run `*trace` (Phase 2) | Confirm Definition of Done, share release notes                                     | Quality audit, Gate YAML + release summary                 |
+| **Phase 4**: Release Gate  | (Optional) `test-review` for final audit, Run `trace` (Phase 2)   | Confirm Definition of Done, share release notes                                    | Quality audit, Gate YAML + release summary                 |
 
 **Key notes:**
-- Run `*framework` and `*ci` once in Phase 3 after architecture.
+- Run `framework` and `ci` once in Phase 3 after architecture.
-- Run `*test-design` per epic in Phase 4; use `*atdd` before dev when helpful.
+- Run `test-design` per epic in Phase 4; use `atdd` before dev when helpful.
-- Use `*trace` for gate decisions; `*test-review` is an optional audit.
+- Use `trace` for gate decisions; `test-review` is an optional audit.
 
 ### Brownfield - BMad Method or Enterprise (Simple or Complex)
 
@@ -233,26 +233,26 @@ These cheat sheets map TEA workflows to the **BMad Method and Enterprise tracks*
 **🔄 Brownfield Deltas from Greenfield:**
 
 - ➕ Documentation (Prerequisite) - Document existing codebase if undocumented
-- ➕ Phase 2: `*trace` - Baseline existing test coverage before planning
+- ➕ Phase 2: `trace` - Baseline existing test coverage before planning
-- 🔄 Phase 4: `*test-design` - Focus on regression hotspots and brownfield risks
+- 🔄 Phase 4: `test-design` - Focus on regression hotspots and brownfield risks
-- 🔄 Phase 4: Story Review - May include `*nfr-assess` if not done earlier
+- 🔄 Phase 4: Story Review - May include `nfr-assess` if not done earlier
 
 | Workflow Stage                    | Test Architect                                                              | Dev / Team                                                                          | Outputs                                                                |
 | --------------------------------- | --------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| **Documentation**: Prerequisite ➕ | -                                                                           | Analyst `*document-project` (if undocumented)                                       | Comprehensive project documentation                                    |
+| **Documentation**: Prerequisite ➕ | -                                                                           | Analyst `document-project` (if undocumented)                                       | Comprehensive project documentation                                    |
-| **Phase 1**: Discovery            | -                                                                           | Analyst/PM/Architect rerun planning workflows                                       | Updated planning artifacts in `{output_folder}`                        |
+| **Phase 1**: Discovery            | -                                                                           | Analyst/PM/Architect rerun planning workflows                                      | Updated planning artifacts in `{output_folder}`                        |
-| **Phase 2**: Planning             | Run ➕ `*trace` (baseline coverage)                                          | PM `*prd` (creates PRD with FRs/NFRs)                                               | PRD with FRs/NFRs, ➕ coverage baseline                                 |
+| **Phase 2**: Planning             | Run ➕ `trace` (baseline coverage)                                           | PM `prd` (creates PRD with FRs/NFRs)                                               | PRD with FRs/NFRs, ➕ coverage baseline                                 |
-| **Phase 3**: Solutioning          | Run `*framework`, `*ci` AFTER architecture and epic creation                | Architect `*architecture`, `*create-epics-and-stories`, `*implementation-readiness` | Architecture, epics/stories, test framework, CI pipeline               |
+| **Phase 3**: Solutioning          | Run `framework`, `ci` AFTER architecture and epic creation                  | Architect `architecture`, `create-epics-and-stories`, `implementation-readiness`   | Architecture, epics/stories, test framework, CI pipeline               |
-| **Phase 4**: Sprint Start         | -                                                                           | SM `*sprint-planning`                                                               | Sprint status file with all epics and stories                          |
+| **Phase 4**: Sprint Start         | -                                                                           | SM `sprint-planning`                                                               | Sprint status file with all epics and stories                          |
-| **Phase 4**: Epic Planning        | Run `*test-design` for THIS epic 🔄 (regression hotspots)                    | Review epic scope and brownfield risks                                              | `test-design-epic-N.md` with brownfield risk assessment and mitigation |
+| **Phase 4**: Epic Planning        | Run `test-design` for THIS epic 🔄 (regression hotspots)                     | Review epic scope and brownfield risks                                             | `test-design-epic-N.md` with brownfield risk assessment and mitigation |
-| **Phase 4**: Story Dev            | (Optional) `*atdd` before dev, then `*automate` after                       | SM `*create-story`, DEV implements                                                  | Tests, story implementation                                            |
+| **Phase 4**: Story Dev            | (Optional) `atdd` before dev, then `automate` after                         | SM `create-story`, DEV implements                                                  | Tests, story implementation                                            |
-| **Phase 4**: Story Review         | Apply `*test-review` (optional), re-run `*trace`, ➕ `*nfr-assess` if needed | Resolve gaps, update docs/tests                                                     | Quality report, refreshed coverage matrix, NFR report                  |
+| **Phase 4**: Story Review         | Apply `test-review` (optional), re-run `trace`, ➕ `nfr-assess` if needed    | Resolve gaps, update docs/tests                                                    | Quality report, refreshed coverage matrix, NFR report                  |
-| **Phase 4**: Release Gate         | (Optional) `*test-review` for final audit, Run `*trace` (Phase 2)           | Capture sign-offs, share release notes                                              | Quality audit, Gate YAML + release summary                             |
+| **Phase 4**: Release Gate         | (Optional) `test-review` for final audit, Run `trace` (Phase 2)             | Capture sign-offs, share release notes                                             | Quality audit, Gate YAML + release summary                             |
 
 **Key notes:**
-- Start with `*trace` in Phase 2 to baseline coverage.
+- Start with `trace` in Phase 2 to baseline coverage.
-- Focus `*test-design` on regression hotspots and integration risk.
+- Focus `test-design` on regression hotspots and integration risk.
-- Run `*nfr-assess` before the gate if it wasn't done earlier.
+- Run `nfr-assess` before the gate if it wasn't done earlier.
 
 ### Greenfield - Enterprise Method (Enterprise/Compliance Work)
 
@@ -261,54 +261,54 @@ These cheat sheets map TEA workflows to the **BMad Method and Enterprise tracks*
 
 **🏢 Enterprise Deltas from BMad Method:**
 
-- ➕ Phase 1: `*research` - Domain and compliance research (recommended)
+- ➕ Phase 1: `research` - Domain and compliance research (recommended)
-- ➕ Phase 2: `*nfr-assess` - Capture NFR requirements early (security/performance/reliability)
+- ➕ Phase 2: `nfr-assess` - Capture NFR requirements early (security/performance/reliability)
-- 🔄 Phase 4: `*test-design` - Enterprise focus (compliance, security architecture alignment)
+- 🔄 Phase 4: `test-design` - Enterprise focus (compliance, security architecture alignment)
 - 📦 Release Gate - Archive artifacts and compliance evidence for audits
 
 | Workflow Stage             | Test Architect                                                          | Dev / Team                                                                          | Outputs                                                            |
 | -------------------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
-| **Phase 1**: Discovery     | -                                                                       | Analyst ➕ `*research`, `*product-brief`                                             | Domain research, compliance analysis, product brief                |
+| **Phase 1**: Discovery     | -                                                                       | Analyst ➕ `research`, `product-brief`                                               | Domain research, compliance analysis, product brief                |
-| **Phase 2**: Planning      | Run ➕ `*nfr-assess`                                                     | PM `*prd` (creates PRD with FRs/NFRs), UX `*create-ux-design`                       | Enterprise PRD with FRs/NFRs, UX design, ➕ NFR documentation       |
+| **Phase 2**: Planning      | Run ➕ `nfr-assess`                                                      | PM `prd` (creates PRD with FRs/NFRs), UX `create-ux-design`                         | Enterprise PRD with FRs/NFRs, UX design, ➕ NFR documentation       |
-| **Phase 3**: Solutioning   | Run `*framework`, `*ci` AFTER architecture and epic creation            | Architect `*architecture`, `*create-epics-and-stories`, `*implementation-readiness` | Architecture, epics/stories, test framework, CI pipeline           |
+| **Phase 3**: Solutioning   | Run `framework`, `ci` AFTER architecture and epic creation              | Architect `architecture`, `create-epics-and-stories`, `implementation-readiness`   | Architecture, epics/stories, test framework, CI pipeline           |
-| **Phase 4**: Sprint Start  | -                                                                       | SM `*sprint-planning`                                                               | Sprint plan with all epics                                         |
+| **Phase 4**: Sprint Start  | -                                                                       | SM `sprint-planning`                                                               | Sprint plan with all epics                                         |
-| **Phase 4**: Epic Planning | Run `*test-design` for THIS epic 🔄 (compliance focus)                   | Review epic scope and compliance requirements                                       | `test-design-epic-N.md` with security/performance/compliance focus |
+| **Phase 4**: Epic Planning | Run `test-design` for THIS epic 🔄 (compliance focus)                    | Review epic scope and compliance requirements                                      | `test-design-epic-N.md` with security/performance/compliance focus |
-| **Phase 4**: Story Dev     | (Optional) `*atdd`, `*automate`, `*test-review`, `*trace` per story     | SM `*create-story`, DEV implements                                                  | Tests, fixtures, quality reports, coverage matrices                |
+| **Phase 4**: Story Dev     | (Optional) `atdd`, `automate`, `test-review`, `trace` per story         | SM `create-story`, DEV implements                                                  | Tests, fixtures, quality reports, coverage matrices                |
-| **Phase 4**: Release Gate  | Final `*test-review` audit, Run `*trace` (Phase 2), 📦 archive artifacts | Capture sign-offs, 📦 compliance evidence                                            | Quality audit, updated assessments, gate YAML, 📦 audit trail       |
+| **Phase 4**: Release Gate  | Final `test-review` audit, Run `trace` (Phase 2), 📦 archive artifacts   | Capture sign-offs, 📦 compliance evidence                                           | Quality audit, updated assessments, gate YAML, 📦 audit trail       |
 
 **Key notes:**
-- Run `*nfr-assess` early in Phase 2.
+- Run `nfr-assess` early in Phase 2.
-- `*test-design` emphasizes compliance, security, and performance alignment.
+- `test-design` emphasizes compliance, security, and performance alignment.
 - Archive artifacts at the release gate for audits.
 
 **Related how-to guides:**
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md)
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md)
-- [How to Set Up a Test Framework](/docs/how-to/workflows/setup-test-framework.md)
+- [How to Set Up a Test Framework](/docs/tea/how-to/workflows/setup-test-framework.md)
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md)
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md)
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md)
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md)
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md)
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md)
-- [How to Set Up CI Pipeline](/docs/how-to/workflows/setup-ci.md)
+- [How to Set Up CI Pipeline](/docs/tea/how-to/workflows/setup-ci.md)
-- [How to Run NFR Assessment](/docs/how-to/workflows/run-nfr-assess.md)
+- [How to Run NFR Assessment](/docs/tea/how-to/workflows/run-nfr-assess.md)
-- [How to Run Trace](/docs/how-to/workflows/run-trace.md)
+- [How to Run Trace](/docs/tea/how-to/workflows/run-trace.md)
 
 ## Deep Dive Concepts
 
 Want to understand TEA principles and patterns in depth?
 
 **Core Principles:**
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Probability × impact scoring, P0-P3 priorities
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Probability × impact scoring, P0-P3 priorities
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Definition of Done, determinism, isolation
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Definition of Done, determinism, isolation
-- [Knowledge Base System](/docs/explanation/tea/knowledge-base-system.md) - Context engineering with tea-index.csv
+- [Knowledge Base System](/docs/tea/explanation/knowledge-base-system.md) - Context engineering with tea-index.csv
 
 **Technical Patterns:**
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Pure function → fixture → composition
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Pure function → fixture → composition
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Eliminating flakiness with intercept-before-navigate
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Eliminating flakiness with intercept-before-navigate
 
 **Engagement & Strategy:**
-- [Engagement Models](/docs/explanation/tea/engagement-models.md) - TEA Lite, TEA Solo, TEA Integrated (5 models explained)
+- [Engagement Models](/docs/tea/explanation/engagement-models.md) - TEA Lite, TEA Solo, TEA Integrated (5 models explained)
 
 **Philosophy:**
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - **Start here to understand WHY TEA exists** - The problem with AI-generated tests and TEA's three-part solution
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - **Start here to understand WHY TEA exists** - The problem with AI-generated tests and TEA's three-part solution
 
 ## Optional Integrations
 
@@ -318,7 +318,7 @@ Production-ready fixtures and utilities that enhance TEA workflows.
 
 - Install: `npm install -D @seontechnologies/playwright-utils`
 > Note: Playwright Utils is enabled via the installer. Only set `tea_use_playwright_utils` in `_bmad/bmm/config.yaml` if you need to override the installer choice.
-- Impacts: `*framework`, `*atdd`, `*automate`, `*test-review`, `*ci`
+- Impacts: `framework`, `atdd`, `automate`, `test-review`, `ci`
 - Utilities include: api-request, auth-session, network-recorder, intercept-network-call, recurse, log, file-utils, burn-in, network-error-monitor, fixtures-composition
 
 ### Playwright MCP Enhancements
@@ -347,8 +347,8 @@ Live browser verification for test design and automation.
 }
 ```
 
-- Helps `*test-design` validate actual UI behavior.
+- Helps `test-design` validate actual UI behavior.
-- Helps `*atdd` and `*automate` verify selectors against the live DOM.
+- Helps `atdd` and `automate` verify selectors against the live DOM.
 - Enhances healing with `browser_snapshot`, console, network, and locator tools.
 
 **To disable**: set `tea_use_mcp_enhancements: false` in `_bmad/bmm/config.yaml` or remove MCPs from IDE config.
@@ -360,51 +360,51 @@ Live browser verification for test design and automation.
 ### Start Here
 
 **New to TEA? Start with the tutorial:**
-- [TEA Lite Quickstart Tutorial](/docs/tutorials/getting-started/tea-lite-quickstart.md) - 30-minute beginner guide using TodoMVC
+- [TEA Lite Quickstart Tutorial](/docs/tea/tutorials/tea-lite-quickstart.md) - 30-minute beginner guide using TodoMVC
 
 ### Workflow Guides (Task-Oriented)
 
 **All 8 TEA workflows with step-by-step instructions:**
-1. [How to Set Up a Test Framework with TEA](/docs/how-to/workflows/setup-test-framework.md) - Scaffold Playwright or Cypress
+1. [How to Set Up a Test Framework with TEA](/docs/tea/how-to/workflows/setup-test-framework.md) - Scaffold Playwright or Cypress
-2. [How to Set Up CI Pipeline with TEA](/docs/how-to/workflows/setup-ci.md) - Configure CI/CD with selective testing
+2. [How to Set Up CI Pipeline with TEA](/docs/tea/how-to/workflows/setup-ci.md) - Configure CI/CD with selective testing
-3. [How to Run Test Design with TEA](/docs/how-to/workflows/run-test-design.md) - Risk-based test planning (system or epic)
+3. [How to Run Test Design with TEA](/docs/tea/how-to/workflows/run-test-design.md) - Risk-based test planning (system or epic)
-4. [How to Run ATDD with TEA](/docs/how-to/workflows/run-atdd.md) - Generate failing tests before implementation
+4. [How to Run ATDD with TEA](/docs/tea/how-to/workflows/run-atdd.md) - Generate failing tests before implementation
-5. [How to Run Automate with TEA](/docs/how-to/workflows/run-automate.md) - Expand test coverage after implementation
+5. [How to Run Automate with TEA](/docs/tea/how-to/workflows/run-automate.md) - Expand test coverage after implementation
-6. [How to Run Test Review with TEA](/docs/how-to/workflows/run-test-review.md) - Audit test quality (0-100 scoring)
+6. [How to Run Test Review with TEA](/docs/tea/how-to/workflows/run-test-review.md) - Audit test quality (0-100 scoring)
-7. [How to Run NFR Assessment with TEA](/docs/how-to/workflows/run-nfr-assess.md) - Validate non-functional requirements
+7. [How to Run NFR Assessment with TEA](/docs/tea/how-to/workflows/run-nfr-assess.md) - Validate non-functional requirements
-8. [How to Run Trace with TEA](/docs/how-to/workflows/run-trace.md) - Coverage traceability + gate decisions
+8. [How to Run Trace with TEA](/docs/tea/how-to/workflows/run-trace.md) - Coverage traceability + gate decisions
 
 ### Customization & Integration
 
 **Optional enhancements to TEA workflows:**
-- [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) - Production-ready fixtures and 9 utilities
+- [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) - Production-ready fixtures and 9 utilities
-- [Enable TEA MCP Enhancements](/docs/how-to/customization/enable-tea-mcp-enhancements.md) - Live browser verification, visual debugging
+- [Enable TEA MCP Enhancements](/docs/tea/how-to/customization/enable-tea-mcp-enhancements.md) - Live browser verification, visual debugging
 
 ### Use-Case Guides
 
 **Specialized guidance for specific contexts:**
-- [Using TEA with Existing Tests (Brownfield)](/docs/how-to/brownfield/use-tea-with-existing-tests.md) - Incremental improvement, regression hotspots, baseline coverage
+- [Using TEA with Existing Tests (Brownfield)](/docs/tea/how-to/brownfield/use-tea-with-existing-tests.md) - Incremental improvement, regression hotspots, baseline coverage
-- [Running TEA for Enterprise](/docs/how-to/brownfield/use-tea-for-enterprise.md) - Compliance, NFR assessment, audit trails, SOC 2/HIPAA
+- [Running TEA for Enterprise](/docs/tea/how-to/brownfield/use-tea-for-enterprise.md) - Compliance, NFR assessment, audit trails, SOC 2/HIPAA
 
 ### Concept Deep Dives (Understanding-Oriented)
 
 **Understand the principles and patterns:**
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Probability × impact scoring, P0-P3 priorities, mitigation strategies
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Probability × impact scoring, P0-P3 priorities, mitigation strategies
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Definition of Done, determinism, isolation, explicit assertions
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Definition of Done, determinism, isolation, explicit assertions
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Pure function → fixture → composition pattern
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Pure function → fixture → composition pattern
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Intercept-before-navigate, eliminating flakiness
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Intercept-before-navigate, eliminating flakiness
-- [Knowledge Base System](/docs/explanation/tea/knowledge-base-system.md) - Context engineering with tea-index.csv, 33 fragments
+- [Knowledge Base System](/docs/tea/explanation/knowledge-base-system.md) - Context engineering with tea-index.csv, 33 fragments
-- [Engagement Models](/docs/explanation/tea/engagement-models.md) - TEA Lite, TEA Solo, TEA Integrated (5 models explained)
+- [Engagement Models](/docs/tea/explanation/engagement-models.md) - TEA Lite, TEA Solo, TEA Integrated (5 models explained)
 
 ### Philosophy & Design
 
 **Why TEA exists and how it works:**
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - **Start here to understand WHY** - The problem with AI-generated tests and TEA's three-part solution
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - **Start here to understand WHY** - The problem with AI-generated tests and TEA's three-part solution
 
 ### Reference (Quick Lookup)
 
 **Factual information for quick reference:**
-- [TEA Command Reference](/docs/reference/tea/commands.md) - All 8 workflows: inputs, outputs, phases, frequency
+- [TEA Command Reference](/docs/tea/reference/commands.md) - All 8 workflows: inputs, outputs, phases, frequency
-- [TEA Configuration Reference](/docs/reference/tea/configuration.md) - Config options, file locations, setup examples
+- [TEA Configuration Reference](/docs/tea/reference/configuration.md) - Config options, file locations, setup examples
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - 33 fragments categorized and explained
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - 33 fragments categorized and explained
-- [Glossary - TEA Section](/docs/reference/glossary/index.md#test-architect-tea-concepts) - 20 TEA-specific terms defined
+- [Glossary - TEA Section](/docs/tea/glossary/index.md#test-architect-tea-concepts) - 20 TEA-specific terms defined

docs/tea/explanation/test-quality-standards.md

@@ -513,7 +513,7 @@ test('fast test', async ({ page, interceptNetworkCall }) => {
 
 ## TEA's Quality Scoring
 
-TEA reviews tests against these standards in `*test-review`:
+TEA reviews tests against these standards in `test-review`:
 
 ### Scoring Categories (100 points total)
 
@@ -725,7 +725,7 @@ test('should create user with valid data', async ({ apiRequest }) => {
 
 ## How TEA Enforces Standards
 
-### During Test Generation (`*atdd`, `*automate`)
+### During Test Generation (`atdd`, `automate`)
 
 TEA generates tests following standards by default:
 
@@ -755,7 +755,7 @@ test('should submit contact form', async ({ page }) => {
 });
 ```
 
-### During Test Review (*test-review)
+### During Test Review (`test-review`)
 
 TEA audits tests and flags violations:
 
@@ -800,7 +800,7 @@ When is a test "done"?
 
 **Code Review DoD:**
 - [ ] Test quality score > 80
-- [ ] No critical issues from `*test-review`
+- [ ] No critical issues from `test-review`
 - [ ] Follows project patterns (fixtures, selectors)
 - [ ] Test reviewed by team member
 
@@ -866,41 +866,41 @@ test('should work with optional button', async ({ page }) => {
 ## Technical Implementation
 
 For detailed test quality patterns, see:
-- [Test Quality Fragment](/docs/reference/tea/knowledge-base.md#quality-standards)
+- [Test Quality Fragment](/docs/tea/reference/knowledge-base.md#quality-standards)
-- [Test Levels Framework Fragment](/docs/reference/tea/knowledge-base.md#quality-standards)
+- [Test Levels Framework Fragment](/docs/tea/reference/knowledge-base.md#quality-standards)
-- [Complete Knowledge Base Index](/docs/reference/tea/knowledge-base.md)
+- [Complete Knowledge Base Index](/docs/tea/reference/knowledge-base.md)
 
 ## Related Concepts
 
 **Core TEA Concepts:**
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Quality scales with risk
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Quality scales with risk
-- [Knowledge Base System](/docs/explanation/tea/knowledge-base-system.md) - How standards are enforced
+- [Knowledge Base System](/docs/tea/explanation/knowledge-base-system.md) - How standards are enforced
-- [Engagement Models](/docs/explanation/tea/engagement-models.md) - Quality in different models
+- [Engagement Models](/docs/tea/explanation/engagement-models.md) - Quality in different models
 
 **Technical Patterns:**
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Determinism explained
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Determinism explained
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Isolation through fixtures
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Isolation through fixtures
 
 **Overview:**
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Quality standards in lifecycle
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Quality standards in lifecycle
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - Why quality matters
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - Why quality matters
 
 ## Practical Guides
 
 **Workflow Guides:**
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md) - Audit against these standards
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md) - Audit against these standards
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) - Generate quality tests
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md) - Generate quality tests
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Expand with quality
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md) - Expand with quality
 
 **Use-Case Guides:**
-- [Using TEA with Existing Tests](/docs/how-to/brownfield/use-tea-with-existing-tests.md) - Improve legacy quality
+- [Using TEA with Existing Tests](/docs/tea/how-to/brownfield/use-tea-with-existing-tests.md) - Improve legacy quality
-- [Running TEA for Enterprise](/docs/how-to/brownfield/use-tea-for-enterprise.md) - Enterprise quality thresholds
+- [Running TEA for Enterprise](/docs/tea/how-to/brownfield/use-tea-for-enterprise.md) - Enterprise quality thresholds
 
 ## Reference
 
-- [TEA Command Reference](/docs/reference/tea/commands.md) - *test-review command
+- [TEA Command Reference](/docs/tea/reference/commands.md) - `test-review` command
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Test quality fragment
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Test quality fragment
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - TEA terminology
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - TEA terminology
 
 ---
 

docs/tea/explanation/testing-as-engineering.md

@@ -55,14 +55,14 @@ A quality operating model packaged as eight executable workflows spanning test d
 
 | Workflow | Purpose |
 |----------|---------|
-| `*test-design` | Risk-based test planning per epic |
+| `test-design` | Risk-based test planning per epic |
-| `*framework` | Scaffold production-ready test infrastructure |
+| `framework` | Scaffold production-ready test infrastructure |
-| `*ci` | CI pipeline with selective testing |
+| `ci` | CI pipeline with selective testing |
-| `*atdd` | Acceptance test-driven development |
+| `atdd` | Acceptance test-driven development |
-| `*automate` | Prioritized test automation |
+| `automate` | Prioritized test automation |
-| `*test-review` | Test quality audits (0-100 score) |
+| `test-review` | Test quality audits (0-100 score) |
-| `*nfr-assess` | Non-functional requirements assessment |
+| `nfr-assess` | Non-functional requirements assessment |
-| `*trace` | Coverage traceability and gate decisions |
+| `trace` | Coverage traceability and gate decisions |
 
 :::tip[Key Insight]
 TEA doesn't just generate tests—it provides a complete quality operating model with workflows for planning, execution, and release gates.
@@ -105,8 +105,8 @@ The three-part stack addresses each gap:
 | Gap | Solution |
 |-----|----------|
 | No standards | Playwright-Utils provides production-ready patterns |
-| No planning | TEA `*test-design` workflow creates risk-based test plans |
+| No planning | TEA `test-design` creates risk-based test plans |
 | No verification | Playwright MCPs validate against live applications |
-| No review | TEA `*test-review` audits quality with scoring |
+| No review | TEA `test-review` audits quality with scoring |
 
 This approach is sometimes called *context engineering*—loading domain-specific standards into AI context automatically rather than relying on prompts alone. TEA's `tea-index.csv` manifest loads relevant knowledge fragments so the AI doesn't relearn testing patterns each session.

docs/tea/glossary/index.md

@@ -101,7 +101,7 @@ Terminology reference for the BMad Method.
 | **Story**               | Single unit of implementable work with clear acceptance criteria, typically 2-8 hours of effort. Grouped into epics.                       |
 | **Story Context**       | Implementation guidance embedded in story files during create-story, referencing existing patterns and approaches.                         |
 | **Story File**          | Markdown file containing story description, acceptance criteria, technical notes, and testing requirements.                                |
-| **Track Selection**     | Automatic analysis by workflow-init suggesting appropriate track based on complexity indicators. User can override.                        |
+| **Track Selection**     | Automatic analysis by `bmad-help` suggesting appropriate track based on complexity indicators. User can override.                        |
 
 ## Game Development Terms
 
@@ -141,7 +141,7 @@ Terminology reference for the BMad Method.
 | **System-Level Test Design** | Test planning at architecture level (Phase 3) focusing on testability review, ADR mapping, and test infrastructure needs.                                     |
 | **tea-index.csv**            | Manifest file tracking all knowledge fragments, their descriptions, tags, and which workflows load them.                                                      |
 | **TEA Integrated**           | Full BMad Method integration with TEA workflows across all phases (Phase 2, 3, 4, and Release Gate).                                                          |
-| **TEA Lite**                 | Beginner approach using just `*automate` workflow to test existing features (simplest way to use TEA).                                                        |
+| **TEA Lite**                 | Beginner approach using just `automate` to test existing features (simplest way to use TEA).                                                        |
 | **TEA Solo**                 | Standalone engagement model using TEA without full BMad Method integration (bring your own requirements).                                                     |
 | **Test Priorities**          | Classification system for test importance: P0 (critical path), P1 (high value), P2 (medium value), P3 (low value).                                            |
 
@@ -149,10 +149,10 @@ Terminology reference for the BMad Method.
 
 ## See Also
 
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Complete TEA capabilities
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Complete TEA capabilities
-- [TEA Knowledge Base](/docs/reference/tea/knowledge-base.md) - Fragment index
+- [TEA Knowledge Base](/docs/tea/reference/knowledge-base.md) - Fragment index
-- [TEA Command Reference](/docs/reference/tea/commands.md) - Workflow reference
+- [TEA Command Reference](/docs/tea/reference/commands.md) - Workflow reference
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Config options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Config options
 
 ---
 

docs/tea/how-to/brownfield/use-tea-for-enterprise.md

@@ -24,7 +24,7 @@ Use TEA on enterprise projects with compliance, security, audit, and regulatory
 
 ## Enterprise-Specific TEA Workflows
 
-### NFR Assessment (*nfr-assess)
+### NFR Assessment (`nfr-assess`)
 
 **Purpose:** Validate non-functional requirements with evidence.
 
@@ -38,7 +38,7 @@ Use TEA on enterprise projects with compliance, security, audit, and regulatory
 
 **Example:**
 ```
-*nfr-assess
+nfr-assess
 
 Categories: Security, Performance, Reliability, Maintainability
 
@@ -56,7 +56,7 @@ Evidence:
 
 **Output:** NFR assessment with PASS/CONCERNS/FAIL for each category.
 
-### Trace with Audit Evidence (*trace)
+### Trace with Audit Evidence (`trace`)
 
 **Purpose:** Requirements traceability with audit trail.
 
@@ -69,7 +69,7 @@ Evidence:
 
 **Example:**
 ```
-*trace Phase 1
+trace Phase 1
 
 Requirements: PRD.md (with compliance requirements)
 Test location: tests/
@@ -83,7 +83,7 @@ Output: traceability-matrix.md with:
 
 **For Release Gate:**
 ```
-*trace Phase 2
+trace Phase 2
 
 Generate gate-decision-{gate_type}-{story_id}.md with:
 - Evidence references
@@ -92,7 +92,7 @@ Generate gate-decision-{gate_type}-{story_id}.md with:
 - Decision rationale
 ```
 
-### Test Design with Compliance Focus (*test-design)
+### Test Design with Compliance Focus (`test-design`)
 
 **Purpose:** Risk assessment with compliance and security focus.
 
@@ -105,7 +105,7 @@ Generate gate-decision-{gate_type}-{story_id}.md with:
 
 **Example:**
 ```
-*test-design
+test-design
 
 Mode: System-level
 
@@ -126,7 +126,7 @@ Output: TWO documents (system-level):
 
 **Research compliance requirements:**
 ```
-Analyst: *research
+Analyst: research
 
 Topics:
 - Industry compliance (SOC 2, HIPAA, GDPR)
@@ -138,7 +138,7 @@ Topics:
 
 **1. Define NFRs early:**
 ```
-PM: *prd
+PM: prd
 
 Include in PRD:
 - Security requirements (authentication, encryption)
@@ -149,7 +149,7 @@ Include in PRD:
 
 **2. Assess NFRs:**
 ```
-TEA: *nfr-assess
+TEA: nfr-assess
 
 Categories: All (Security, Performance, Reliability, Maintainability)
 
@@ -161,7 +161,7 @@ Output: nfr-assessment.md
 
 **3. Baseline (brownfield only):**
 ```
-TEA: *trace Phase 1
+TEA: trace Phase 1
 
 Establish baseline coverage before new work
 ```
@@ -170,9 +170,9 @@ Establish baseline coverage before new work
 
 **1. Architecture with testability review:**
 ```
-Architect: *architecture
+Architect: architecture
 
-TEA: *test-design (system-level)
+TEA: test-design (system-level)
 
 Focus:
 - Security architecture testability
@@ -182,7 +182,7 @@ Focus:
 
 **2. Test infrastructure:**
 ```
-TEA: *framework
+TEA: framework
 
 Requirements:
 - Separate test environments (dev, staging, prod-mirror)
@@ -192,7 +192,7 @@ Requirements:
 
 **3. CI/CD with compliance:**
 ```
-TEA: *ci
+TEA: ci
 
 Requirements:
 - Secrets management (Vault, AWS Secrets Manager)
@@ -205,21 +205,21 @@ Requirements:
 
 **Per epic:**
 ```
-1. TEA: *test-design (epic-level)
+1. TEA: test-design (epic-level)
    Focus: Compliance, security, performance for THIS epic
 
-2. TEA: *atdd (optional)
+2. TEA: atdd (optional)
    Generate tests including security/compliance scenarios
 
 3. DEV: Implement story
 
-4. TEA: *automate
+4. TEA: automate
    Expand coverage including compliance edge cases
 
-5. TEA: *test-review
+5. TEA: test-review
    Audit quality (score >80 per epic, rises to >85 at release)
 
-6. TEA: *trace Phase 1
+6. TEA: trace Phase 1
    Refresh coverage, verify compliance requirements tested
 ```
 
@@ -227,7 +227,7 @@ Requirements:
 
 **1. Final NFR assessment:**
 ```
-TEA: *nfr-assess
+TEA: nfr-assess
 
 All categories (if not done earlier)
 Latest evidence (performance tests, security scans)
@@ -235,7 +235,7 @@ Latest evidence (performance tests, security scans)
 
 **2. Final quality audit:**
 ```
-TEA: *test-review tests/
+TEA: test-review tests/
 
 Full suite review
 Quality target: >85 for enterprise
@@ -243,7 +243,7 @@ Quality target: >85 for enterprise
 
 **3. Gate decision:**
 ```
-TEA: *trace Phase 2
+TEA: trace Phase 2
 
 Evidence required:
 - traceability-matrix.md (from Phase 1)
@@ -374,7 +374,7 @@ compliance/
 **Priority 1:** Security requirements
 ```
 1. Document all security requirements
-2. Generate security tests with *atdd
+2. Generate security tests with `atdd`
 3. Run security test suite
 4. Pass security audit BEFORE moving forward
 ```
@@ -495,30 +495,30 @@ testWithAuth('admin can access admin endpoint', async ({ apiRequest, authToken,
 ## Related Guides
 
 **Workflow Guides:**
-- [How to Run NFR Assessment](/docs/how-to/workflows/run-nfr-assess.md) - Deep dive on NFRs
+- [How to Run NFR Assessment](/docs/tea/how-to/workflows/run-nfr-assess.md) - Deep dive on NFRs
-- [How to Run Trace](/docs/how-to/workflows/run-trace.md) - Gate decisions with evidence
+- [How to Run Trace](/docs/tea/how-to/workflows/run-trace.md) - Gate decisions with evidence
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md) - Quality audits
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md) - Quality audits
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md) - Compliance-focused planning
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md) - Compliance-focused planning
 
 **Use-Case Guides:**
-- [Using TEA with Existing Tests](/docs/how-to/brownfield/use-tea-with-existing-tests.md) - Brownfield patterns
+- [Using TEA with Existing Tests](/docs/tea/how-to/brownfield/use-tea-with-existing-tests.md) - Brownfield patterns
 
 **Customization:**
-- [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) - Production-ready utilities
+- [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) - Production-ready utilities
 
 ## Understanding the Concepts
 
-- [Engagement Models](/docs/explanation/tea/engagement-models.md) - Enterprise model explained
+- [Engagement Models](/docs/tea/explanation/engagement-models.md) - Enterprise model explained
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Probability × impact scoring
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Probability × impact scoring
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Enterprise quality thresholds
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Enterprise quality thresholds
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Complete TEA lifecycle
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Complete TEA lifecycle
 
 ## Reference
 
-- [TEA Command Reference](/docs/reference/tea/commands.md) - All 8 workflows
+- [TEA Command Reference](/docs/tea/reference/commands.md) - All 8 workflows
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Enterprise config options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Enterprise config options
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Testing patterns
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Testing patterns
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - TEA terminology
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - TEA terminology
 
 ---
 

docs/tea/how-to/brownfield/use-tea-with-existing-tests.md

@@ -22,7 +22,7 @@ Use TEA on brownfield projects (existing codebases with legacy tests) to establi
 - Existing codebase with tests (even if incomplete or low quality)
 - Tests run successfully (or at least can be executed)
 
-**Note:** If your codebase is completely undocumented, run `*document-project` first to create baseline documentation.
+**Note:** If your codebase is completely undocumented, run `document-project` first to create baseline documentation.
 
 ## Brownfield Strategy
 
@@ -30,12 +30,12 @@ Use TEA on brownfield projects (existing codebases with legacy tests) to establi
 
 Understand what you have before changing anything.
 
-#### Step 1: Baseline Coverage with *trace
+#### Step 1: Baseline Coverage with `trace`
 
-Run `*trace` Phase 1 to map existing tests to requirements:
+Run `trace` Phase 1 to map existing tests to requirements:
 
 ```
-*trace
+trace
 ```
 
 **Select:** Phase 1 (Requirements Traceability)
@@ -68,12 +68,12 @@ Run `*trace` Phase 1 to map existing tests to requirements:
 
 This baseline becomes your improvement target.
 
-#### Step 2: Quality Audit with *test-review
+#### Step 2: Quality Audit with `test-review`
 
-Run `*test-review` on existing tests:
+Run `test-review` on existing tests:
 
 ```
-*test-review tests/
+test-review tests/
 ```
 
 **Output:** `test-review.md` with quality score and issues.
@@ -113,7 +113,7 @@ Goal: Get P0 coverage to 100%
 
 Actions:
 1. Identify P0 requirements with no tests (from trace)
-2. Run *automate to generate tests for missing P0 scenarios
+2. Run `automate` to generate tests for missing P0 scenarios
 3. Fix critical quality issues in P0 tests (from test-review)
 ```
 
@@ -183,7 +183,7 @@ test('checkout completes', async ({ page, interceptNetworkCall }) => {
 - Glob pattern matching (`**/api/checkout`)
 - Cleaner, more maintainable code
 
-**For automatic error detection,** use `network-error-monitor` fixture separately. See [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md#network-error-monitor).
+**For automatic error detection,** use `network-error-monitor` fixture separately. See [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md#network-error-monitor).
 
 **Priority 3: P1 Requirements**
 ```
@@ -228,11 +228,11 @@ Apply TEA workflows to new work while improving legacy tests.
 
 **Use full TEA workflow:**
 ```
-1. *test-design (epic-level) - Plan tests for new feature
+1. `test-design` (epic-level) - Plan tests for new feature
-2. *atdd - Generate failing tests first (TDD)
+2. `atdd` - Generate failing tests first (TDD)
 3. Implement feature
-4. *automate - Expand coverage
+4. `automate` - Expand coverage
-5. *test-review - Ensure quality
+5. `test-review` - Ensure quality
 ```
 
 **Benefits:**
@@ -247,7 +247,7 @@ Apply TEA workflows to new work while improving legacy tests.
 1. Reproduce bug with failing test
 2. Fix bug
 3. Verify test passes
-4. Run *test-review on regression test
+4. Run `test-review` on regression test
 5. Add to regression test suite
 ```
 
@@ -255,10 +255,10 @@ Apply TEA workflows to new work while improving legacy tests.
 
 **Before refactoring:**
 ```
-1. Run *trace - Baseline coverage
+1. Run `trace` - Baseline coverage
 2. Note current coverage %
 3. Refactor code
-4. Run *trace - Verify coverage maintained
+4. Run `trace` - Verify coverage maintained
 5. No coverage should decrease
 ```
 
@@ -375,7 +375,7 @@ test.skip('flaky test - needs fixing', async ({ page }) => {
 
 **Week 1:** `tests/auth/`
 ```
-1. Run *test-review on auth tests
+1. Run `test-review` on auth tests
 2. Fix critical issues
 3. Re-review
 4. Mark directory as "modernized"
@@ -425,7 +425,7 @@ Same process
 
 **Solution:**
 ```
-1. Run *trace - TEA analyzes tests and maps to requirements
+1. Run `trace` - TEA analyzes tests and maps to requirements
 2. Review traceability matrix
 3. Document findings
 4. Use as baseline for improvement
@@ -463,7 +463,7 @@ Incremental changes = lower risk
 3. Commit documentation for team
 ```
 
-**Note:** `*framework` is for new test setup, not existing tests. For brownfield, document what you have.
+**Note:** `framework` is for new test setup, not existing tests. For brownfield, document what you have.
 
 ### "Tests Take Hours to Run"
 
@@ -480,7 +480,7 @@ Before: 4 hours sequential
 After: 15 minutes with sharding + selective testing
 ```
 
-**How `*ci` helps:**
+**How `ci` helps:**
 - Scaffolds CI configuration with parallel sharding examples
 - Provides selective testing script templates
 - Documents burn-in and optimization strategies
@@ -489,7 +489,7 @@ After: 15 minutes with sharding + selective testing
 **With Playwright Utils burn-in:**
 - Smart selective testing based on git diff
 - Volume control (run percentage of affected tests)
-- See [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md#burn-in)
+- See [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md#burn-in)
 
 ### "We Have Tests But They Always Fail"
 
@@ -497,7 +497,7 @@ After: 15 minutes with sharding + selective testing
 
 **Solution:**
 ```
-1. Run *test-review to identify flakiness patterns
+1. Run `test-review` to identify flakiness patterns
 2. Fix top 5 flaky tests (biggest impact)
 3. Quarantine remaining flaky tests
 4. Re-enable as you fix them
@@ -511,66 +511,66 @@ Don't let perfect be the enemy of good
 
 **1. Documentation (if needed):**
 ```
-*document-project
+document-project
 ```
 
 **2. Baseline (Phase 2):**
 ```
-*trace Phase 1 - Establish coverage baseline
+trace Phase 1 - Establish coverage baseline
-*test-review - Establish quality baseline
+test-review - Establish quality baseline
 ```
 
 **3. Planning (Phase 2-3):**
 ```
-*prd - Document requirements (if missing)
+prd - Document requirements (if missing)
-*architecture - Document architecture (if missing)
+architecture - Document architecture (if missing)
-*test-design (system-level) - Testability review
+test-design (system-level) - Testability review
 ```
 
 **4. Infrastructure (Phase 3):**
 ```
-*framework - Modernize test framework (if needed)
+framework - Modernize test framework (if needed)
-*ci - Setup or improve CI/CD
+ci - Setup or improve CI/CD
 ```
 
 **5. Per Epic (Phase 4):**
 ```
-*test-design (epic-level) - Focus on regression hotspots
+test-design (epic-level) - Focus on regression hotspots
-*automate - Add missing tests
+automate - Add missing tests
-*test-review - Ensure quality
+test-review - Ensure quality
-*trace Phase 1 - Refresh coverage
+trace Phase 1 - Refresh coverage
 ```
 
 **6. Release Gate:**
 ```
-*nfr-assess - Validate NFRs (if enterprise)
+nfr-assess - Validate NFRs (if enterprise)
-*trace Phase 2 - Gate decision
+trace Phase 2 - Gate decision
 ```
 
 ## Related Guides
 
 **Workflow Guides:**
-- [How to Run Trace](/docs/how-to/workflows/run-trace.md) - Baseline coverage analysis
+- [How to Run Trace](/docs/tea/how-to/workflows/run-trace.md) - Baseline coverage analysis
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md) - Quality audit
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md) - Quality audit
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Fill coverage gaps
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md) - Fill coverage gaps
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md) - Risk assessment
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md) - Risk assessment
 
 **Customization:**
-- [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) - Modernize tests with utilities
+- [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) - Modernize tests with utilities
 
 ## Understanding the Concepts
 
-- [Engagement Models](/docs/explanation/tea/engagement-models.md) - Brownfield model explained
+- [Engagement Models](/docs/tea/explanation/engagement-models.md) - Brownfield model explained
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - What makes tests good
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - What makes tests good
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Fix flakiness
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Fix flakiness
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Prioritize improvements
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Prioritize improvements
 
 ## Reference
 
-- [TEA Command Reference](/docs/reference/tea/commands.md) - All 8 workflows
+- [TEA Command Reference](/docs/tea/reference/commands.md) - All 8 workflows
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Config options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Config options
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Testing patterns
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Testing patterns
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - TEA terminology
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - TEA terminology
 
 ---
 

docs/tea/how-to/customization/enable-tea-mcp-enhancements.md

@@ -19,14 +19,14 @@ MCP (Model Context Protocol) servers enable AI agents to interact with live brow
 ## When to Use This
 
 **For UI Testing:**
-- Want exploratory mode in `*test-design` (browser-based UI discovery)
+- Want exploratory mode in `test-design` (browser-based UI discovery)
-- Want recording mode in `*atdd` or `*automate` (verify selectors with live browser)
+- Want recording mode in `atdd` or `automate` (verify selectors with live browser)
-- Want healing mode in `*automate` (fix tests with visual debugging)
+- Want healing mode in `automate` (fix tests with visual debugging)
 - Need accurate selectors from actual DOM
 - Debugging complex UI interactions
 
 **For API Testing:**
-- Want healing mode in `*automate` (analyze failures with trace data)
+- Want healing mode in `automate` (analyze failures with trace data)
 - Need to debug test failures (network responses, request/response data, timing)
 - Want to inspect trace files (network traffic, errors, race conditions)
 
@@ -100,7 +100,7 @@ Add to your IDE's MCP configuration:
 }
 ```
 
-See [TEA Overview](/docs/explanation/features/tea-overview.md#playwright-mcp-enhancements) for IDE-specific config locations.
+See [TEA Overview](/docs/tea/explanation/tea-overview.md#playwright-mcp-enhancements) for IDE-specific config locations.
 
 ### 2. Enable in BMAD
 
@@ -117,7 +117,7 @@ Ensure your MCP servers are running in your IDE.
 
 ## How MCP Enhances TEA Workflows
 
-### *test-design: Exploratory Mode
+### test-design: Exploratory Mode
 
 **Without MCP:**
 - TEA infers UI functionality from documentation
@@ -148,7 +148,7 @@ I'll design tests for these interactions."
 - Discovers functionality you might not describe
 - Validates test scenarios are possible
 
-### *atdd: Recording Mode
+### atdd: Recording Mode
 
 **Without MCP:**
 - TEA generates selectors from best practices
@@ -187,7 +187,7 @@ I'll validate these in tests."
 - API: Validated request/response patterns from trace
 - Both: Tests work on first run
 
-### *automate: Healing + Recording Modes
+### automate: Healing + Recording Modes
 
 **Without MCP:**
 - TEA analyzes test code only
@@ -227,7 +227,7 @@ API: [Analyzes network traffic, validates request/response patterns]
 ### Exploratory Mode Example
 
 ```
-User: Run *test-design
+User: Run test-design
 
 TEA: What feature are you designing tests for?
 
@@ -252,7 +252,7 @@ Test design will cover all these scenarios.
 ### Recording Mode Example
 
 ```
-User: Run *atdd for user registration feature
+User: Run atdd for user registration feature
 
 TEA: [With MCP] Let me verify the registration form selectors
 [Opens browser at /register]
@@ -271,7 +271,7 @@ Generating tests with verified selectors...
 ### Healing Mode Example
 
 ```
-User: Run *automate with healing mode
+User: Run automate with healing mode
 
 TEA: [With MCP] Running tests and checking for failures
 [Runs test suite]
@@ -398,26 +398,26 @@ tea_use_mcp_enhancements: false
 ## Related Guides
 
 **Getting Started:**
-- [TEA Lite Quickstart Tutorial](/docs/tutorials/getting-started/tea-lite-quickstart.md) - Learn TEA basics first
+- [TEA Lite Quickstart Tutorial](/docs/tea/tutorials/tea-lite-quickstart.md) - Learn TEA basics first
 
 **Workflow Guides (MCP-Enhanced):**
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md) - Exploratory mode with browser
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md) - Exploratory mode with browser
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) - Recording mode for accurate selectors
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md) - Recording mode for accurate selectors
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Healing mode for debugging
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md) - Healing mode for debugging
 
 **Other Customization:**
-- [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) - Production-ready utilities
+- [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) - Production-ready utilities
 
 ## Understanding the Concepts
 
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - MCP enhancements in lifecycle
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - MCP enhancements in lifecycle
-- [Engagement Models](/docs/explanation/tea/engagement-models.md) - When to use MCP enhancements
+- [Engagement Models](/docs/tea/explanation/engagement-models.md) - When to use MCP enhancements
 
 ## Reference
 
-- [TEA Configuration](/docs/reference/tea/configuration.md) - tea_use_mcp_enhancements option
+- [TEA Configuration](/docs/tea/reference/configuration.md) - tea_use_mcp_enhancements option
-- [TEA Command Reference](/docs/reference/tea/commands.md) - MCP-enhanced workflows
+- [TEA Command Reference](/docs/tea/reference/commands.md) - MCP-enhanced workflows
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - MCP Enhancements term
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - MCP Enhancements term
 
 ---
 

docs/tea/how-to/customization/integrate-playwright-utils.md

@@ -82,7 +82,7 @@ tea_use_playwright_utils: true
 
 ## What Changes When Enabled
 
-### *framework Workflow
+### `framework` Workflow
 
 **Vanilla Playwright:**
 ```typescript
@@ -133,7 +133,7 @@ test('api test', async ({ apiRequest, log }) => {
 });
 ```
 
-### `*atdd` and `*automate` Workflows
+### `atdd` and `automate` Workflows
 
 **Without Playwright Utils:**
 ```typescript
@@ -160,7 +160,7 @@ test('should fetch profile', async ({ apiRequest }) => {
 });
 ```
 
-### *test-review Workflow
+### `test-review` Workflow
 
 **Without Playwright Utils:**
 Reviews against generic Playwright patterns
@@ -172,7 +172,7 @@ Reviews against playwright-utils best practices:
 - Network-first patterns
 - Structured logging
 
-### *ci Workflow
+### `ci` Workflow
 
 **Without Playwright Utils:**
 - Parallel sharding
@@ -783,29 +783,29 @@ expect(status).toBe(200);
 ## Related Guides
 
 **Getting Started:**
-- [TEA Lite Quickstart Tutorial](/docs/tutorials/getting-started/tea-lite-quickstart.md) - Learn TEA basics
+- [TEA Lite Quickstart Tutorial](/docs/tea/tutorials/tea-lite-quickstart.md) - Learn TEA basics
-- [How to Set Up Test Framework](/docs/how-to/workflows/setup-test-framework.md) - Initial framework setup
+- [How to Set Up Test Framework](/docs/tea/how-to/workflows/setup-test-framework.md) - Initial framework setup
 
 **Workflow Guides:**
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) - Generate tests with utilities
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md) - Generate tests with utilities
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Expand coverage with utilities
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md) - Expand coverage with utilities
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md) - Review against PW-Utils patterns
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md) - Review against PW-Utils patterns
 
 **Other Customization:**
-- [Enable MCP Enhancements](/docs/how-to/customization/enable-tea-mcp-enhancements.md) - Live browser verification
+- [Enable MCP Enhancements](/docs/tea/how-to/customization/enable-tea-mcp-enhancements.md) - Live browser verification
 
 ## Understanding the Concepts
 
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - **Why Playwright Utils matters** (part of TEA's three-part solution)
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - **Why Playwright Utils matters** (part of TEA's three-part solution)
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Pure function → fixture pattern
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Pure function → fixture pattern
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Network utilities explained
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Network utilities explained
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Patterns PW-Utils enforces
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Patterns PW-Utils enforces
 
 ## Reference
 
-- [TEA Configuration](/docs/reference/tea/configuration.md) - tea_use_playwright_utils option
+- [TEA Configuration](/docs/tea/reference/configuration.md) - tea_use_playwright_utils option
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Playwright Utils fragments
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Playwright Utils fragments
-- [Glossary](/docs/reference/glossary/index.md#test-architect-tea-concepts) - Playwright Utils term
+- [Glossary](/docs/tea/glossary/index.md#test-architect-tea-concepts) - Playwright Utils term
 - [Official PW-Utils Docs](https://seontechnologies.github.io/playwright-utils/) - Complete API reference
 
 ---

docs/tea/how-to/workflows/run-atdd.md

@@ -5,7 +5,7 @@ description: Generate failing acceptance tests before implementation using TEA's
 
 # How to Run ATDD with TEA
 
-Use TEA's `*atdd` workflow to generate failing acceptance tests BEFORE implementation. This is the TDD (Test-Driven Development) red phase - tests fail first, guide development, then pass.
+Use TEA's `atdd` workflow to generate failing acceptance tests BEFORE implementation. This is the TDD (Test-Driven Development) red phase - tests fail first, guide development, then pass.
 
 ## When to Use This
 
@@ -15,14 +15,14 @@ Use TEA's `*atdd` workflow to generate failing acceptance tests BEFORE implement
 - You're practicing acceptance test-driven development
 
 **Don't use this if:**
-- Feature already exists (use `*automate` instead)
+- Feature already exists (use `automate` instead)
 - You want tests that pass immediately
 
 ## Prerequisites
 
 - BMad Method installed
 - TEA agent available
-- Test framework setup complete (run `*framework` if needed)
+- Test framework setup complete (run `framework` if needed)
 - Story or feature defined with acceptance criteria
 
 **Note:** This guide uses Playwright examples. If using Cypress, commands and syntax will differ (e.g., `cy.get()` instead of `page.locator()`).
@@ -34,13 +34,13 @@ Use TEA's `*atdd` workflow to generate failing acceptance tests BEFORE implement
 Start a fresh chat and load TEA:
 
 ```
-*tea
+tea
 ```
 
 ### 2. Run the ATDD Workflow
 
 ```
-*atdd
+atdd
 ```
 
 ### 3. Provide Context
@@ -80,7 +80,7 @@ And changes are not saved
 **Reference Documents** (optional):
 - Point to your story file
 - Reference PRD or tech spec
-- Link to test design (if you ran `*test-design` first)
+- Link to test design (if you ran `test-design` first)
 
 ### 4. Specify Test Levels
 
@@ -367,20 +367,20 @@ Running 6 tests using 1 worker
 
 ### Start with Test Design
 
-Run `*test-design` before `*atdd` for better results:
+Run `test-design` before `atdd` for better results:
 
 ```
-*test-design   # Risk assessment and priorities
+test-design   # Risk assessment and priorities
-*atdd          # Generate tests based on design
+atdd          # Generate tests based on design
 ```
 
 ### MCP Enhancements (Optional)
 
-If you have MCP servers configured (`tea_use_mcp_enhancements: true`), TEA can use them during `*atdd`.
+If you have MCP servers configured (`tea_use_mcp_enhancements: true`), TEA can use them during `atdd`.
 
 **Note:** ATDD is for features that don't exist yet, so recording mode (verify selectors with live UI) only applies if you have skeleton/mockup UI already implemented. For typical ATDD (no UI yet), TEA infers selectors from best practices.
 
-See [Enable MCP Enhancements](/docs/how-to/customization/enable-tea-mcp-enhancements.md) for setup.
+See [Enable MCP Enhancements](/docs/tea/how-to/customization/enable-tea-mcp-enhancements.md) for setup.
 
 ### Focus on P0/P1 Scenarios
 
@@ -391,15 +391,15 @@ Generate tests for:
 - P0: Critical path (happy path)
 - P1: High value (validation, errors)
 
-Skip P2/P3 for now - add later with *automate
+Skip P2/P3 for now - add later with automate
 ```
 
 ### API Tests First, E2E Later
 
 Recommended order:
-1. Generate API tests with `*atdd`
+1. Generate API tests with `atdd`
 2. Implement backend (make API tests pass)
-3. Generate E2E tests with `*atdd` (or `*automate`)
+3. Generate E2E tests with `atdd` (or `automate`)
 4. Implement frontend (make E2E tests pass)
 
 This "outside-in" approach is faster and more reliable.
@@ -415,21 +415,21 @@ Don't modify these patterns - they prevent flakiness!
 
 ## Related Guides
 
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md) - Plan before generating
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md) - Plan before generating
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Tests for existing features
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md) - Tests for existing features
-- [How to Set Up Test Framework](/docs/how-to/workflows/setup-test-framework.md) - Initial setup
+- [How to Set Up Test Framework](/docs/tea/how-to/workflows/setup-test-framework.md) - Initial setup
 
 ## Understanding the Concepts
 
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - **Why TEA generates quality tests** (foundational)
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - **Why TEA generates quality tests** (foundational)
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Why P0 vs P3 matters
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Why P0 vs P3 matters
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - What makes tests good
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - What makes tests good
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Avoiding flakiness
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Avoiding flakiness
 
 ## Reference
 
-- [Command: *atdd](/docs/reference/tea/commands.md#atdd) - Full command reference
+- [Command: *atdd](/docs/tea/reference/commands.md#atdd) - Full command reference
-- [TEA Configuration](/docs/reference/tea/configuration.md) - MCP and Playwright Utils options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - MCP and Playwright Utils options
 
 ---
 

docs/tea/how-to/workflows/run-automate.md

@@ -5,7 +5,7 @@ description: Expand test automation coverage after implementation using TEA's au
 
 # How to Run Automate with TEA
 
-Use TEA's `*automate` workflow to generate comprehensive tests for existing features. Unlike `*atdd`, these tests pass immediately because the feature already exists.
+Use TEA's `automate` workflow to generate comprehensive tests for existing features. Unlike `*atdd`, these tests pass immediately because the feature already exists.
 
 ## When to Use This
 
@@ -16,14 +16,14 @@ Use TEA's `*automate` workflow to generate comprehensive tests for existing feat
 - Adding tests to legacy code
 
 **Don't use this if:**
-- Feature doesn't exist yet (use `*atdd` instead)
+- Feature doesn't exist yet (use `atdd` instead)
-- Want failing tests to guide development (use `*atdd` for TDD)
+- Want failing tests to guide development (use `atdd` for TDD)
 
 ## Prerequisites
 
 - BMad Method installed
 - TEA agent available
-- Test framework setup complete (run `*framework` if needed)
+- Test framework setup complete (run `framework` if needed)
 - Feature implemented and working
 
 **Note:** This guide uses Playwright examples. If using Cypress, commands and syntax will differ.
@@ -35,13 +35,13 @@ Use TEA's `*automate` workflow to generate comprehensive tests for existing feat
 Start a fresh chat and load TEA:
 
 ```
-*tea
+tea
 ```
 
 ### 2. Run the Automate Workflow
 
 ```
-*automate
+automate
 ```
 
 ### 3. Provide Context
@@ -501,11 +501,11 @@ TEA supports component testing using framework-appropriate tools:
 
 ### Start with Test Design
 
-Run `*test-design` before `*automate` for better results:
+Run `test-design` before `automate` for better results:
 
 ```
-*test-design   # Risk assessment, priorities
+test-design   # Risk assessment, priorities
-*automate      # Generate tests based on priorities
+automate      # Generate tests based on priorities
 ```
 
 TEA will focus on P0/P1 scenarios and skip low-value tests.
@@ -543,12 +543,12 @@ TEA will analyze existing tests and only generate new scenarios.
 
 ### MCP Enhancements (Optional)
 
-If you have MCP servers configured (`tea_use_mcp_enhancements: true`), TEA can use them during `*automate` for:
+If you have MCP servers configured (`tea_use_mcp_enhancements: true`), TEA can use them during `automate` for:
 
 - **Healing mode:** Fix broken selectors, update assertions, enhance with trace analysis
 - **Recording mode:** Verify selectors with live browser, capture network requests
 
-No prompts - TEA uses MCPs automatically when available. See [Enable MCP Enhancements](/docs/how-to/customization/enable-tea-mcp-enhancements.md) for setup.
+No prompts - TEA uses MCPs automatically when available. See [Enable MCP Enhancements](/docs/tea/how-to/customization/enable-tea-mcp-enhancements.md) for setup.
 
 ### Generate Tests Incrementally
 
@@ -557,20 +557,20 @@ Don't generate all tests at once:
 **Iteration 1:**
 ```
 Generate P0 tests only (critical path)
-Run: *automate
+Run: automate
 ```
 
 **Iteration 2:**
 ```
 Generate P1 tests (high value scenarios)
-Run: *automate
+Run: automate
 Tell TEA to avoid P0 coverage
 ```
 
 **Iteration 3:**
 ```
 Generate P2 tests (if time permits)
-Run: *automate
+Run: automate
 ```
 
 This iterative approach:
@@ -628,25 +628,25 @@ Generate tests for scenarios NOT covered by those files
 
 If you have MCP servers configured, TEA verifies selectors against live browser. Otherwise, TEA generates accessible selectors (`getByRole`, `getByLabel`) by default.
 
-Setup: Answer "Yes" to MCPs in BMad installer + configure MCP servers in your IDE. See [Enable MCP Enhancements](/docs/how-to/customization/enable-tea-mcp-enhancements.md).
+Setup: Answer "Yes" to MCPs in BMad installer + configure MCP servers in your IDE. See [Enable MCP Enhancements](/docs/tea/how-to/customization/enable-tea-mcp-enhancements.md).
 
 ## Related Guides
 
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md) - Plan before generating
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md) - Plan before generating
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) - Failing tests before implementation
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md) - Failing tests before implementation
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md) - Audit generated quality
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md) - Audit generated quality
 
 ## Understanding the Concepts
 
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - **Why TEA generates quality tests** (foundational)
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - **Why TEA generates quality tests** (foundational)
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Why prioritize P0 over P3
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Why prioritize P0 over P3
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - What makes tests good
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - What makes tests good
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Reusable test patterns
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Reusable test patterns
 
 ## Reference
 
-- [Command: *automate](/docs/reference/tea/commands.md#automate) - Full command reference
+- [Command: *automate](/docs/tea/reference/commands.md#automate) - Full command reference
-- [TEA Configuration](/docs/reference/tea/configuration.md) - MCP and Playwright Utils options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - MCP and Playwright Utils options
 
 ---
 

docs/tea/how-to/workflows/run-nfr-assess.md

@@ -5,7 +5,7 @@ description: Validate non-functional requirements for security, performance, rel
 
 # How to Run NFR Assessment with TEA
 
-Use TEA's `*nfr-assess` workflow to validate non-functional requirements (NFRs) with evidence-based assessment across security, performance, reliability, and maintainability.
+Use TEA's `nfr-assess` workflow to validate non-functional requirements (NFRs) with evidence-based assessment across security, performance, reliability, and maintainability.
 
 ## When to Use This
 
@@ -37,7 +37,7 @@ Use TEA's `*nfr-assess` workflow to validate non-functional requirements (NFRs)
 Start a fresh chat and run:
 
 ```
-*nfr-assess
+nfr-assess
 ```
 
 This loads TEA and starts the NFR assessment workflow.
@@ -463,7 +463,7 @@ If business decides to deploy with current performance:
 ### Run NFR Assessment Early
 
 **Phase 2 (Enterprise):**
-Run `*nfr-assess` during planning to:
+Run `nfr-assess` during planning to:
 - Identify NFR requirements early
 - Plan for performance testing
 - Budget for security audits
@@ -559,7 +559,7 @@ After implementing mitigations:
 ```
 1. Fix performance issues
 2. Run load tests again
-3. Run *nfr-assess with new evidence
+3. Run nfr-assess with new evidence
 4. Verify PASS status
 ```
 
@@ -573,7 +573,7 @@ Don't deploy with CONCERNS without mitigation or waiver.
 ### Pre-Release
 - [ ] All tests passing
 - [ ] Test coverage > 80%
-- [ ] Run *nfr-assess
+- [ ] Run nfr-assess
 - [ ] NFR status: PASS or WAIVED
 
 ### Performance
@@ -660,19 +660,19 @@ Assess categories incrementally, not all at once.
 
 ## Related Guides
 
-- [How to Run Trace](/docs/how-to/workflows/run-trace.md) - Gate decision complements NFR
+- [How to Run Trace](/docs/tea/how-to/workflows/run-trace.md) - Gate decision complements NFR
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md) - Quality complements NFR
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md) - Quality complements NFR
-- [Run TEA for Enterprise](/docs/how-to/brownfield/use-tea-for-enterprise.md) - Enterprise workflow
+- [Run TEA for Enterprise](/docs/tea/how-to/brownfield/use-tea-for-enterprise.md) - Enterprise workflow
 
 ## Understanding the Concepts
 
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Risk assessment principles
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Risk assessment principles
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - NFR in release gates
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - NFR in release gates
 
 ## Reference
 
-- [Command: *nfr-assess](/docs/reference/tea/commands.md#nfr-assess) - Full command reference
+- [Command: *nfr-assess](/docs/tea/reference/commands.md#nfr-assess) - Full command reference
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Enterprise config options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Enterprise config options
 
 ---
 

docs/tea/how-to/workflows/run-test-design.md

@@ -3,7 +3,7 @@ title: "How to Run Test Design with TEA"
 description: How to create comprehensive test plans using TEA's test-design workflow
 ---
 
-Use TEA's `*test-design` workflow to create comprehensive test plans with risk assessment and coverage strategies.
+Use TEA's `test-design` workflow to create comprehensive test plans with risk assessment and coverage strategies.
 
 ## When to Use This
 
@@ -33,7 +33,7 @@ Start a fresh chat and load the TEA (Test Architect) agent.
 ### 2. Run the Test Design Workflow
 
 ```
-*test-design
+test-design
 ```
 
 ### 3. Specify the Mode
@@ -122,7 +122,7 @@ TEA produces two focused documents for system-level mode:
 - **Run system-level right after architecture** — Early testability review
 - **Run epic-level at the start of each epic** — Targeted test planning
 - **Update if ADRs change** — Keep test design aligned
-- **Use output to guide other workflows** — Feeds into `*atdd` and `*automate`
+- **Use output to guide other workflows** — Feeds into `atdd` and `automate`
 - **Architecture teams review Architecture doc** — Focus on blockers and mitigation plans
 - **QA teams use QA doc as implementation guide** — Follow test scenarios and Sprint 0 checklist
 

docs/tea/how-to/workflows/run-test-review.md

@@ -5,7 +5,7 @@ description: Audit test quality using TEA's comprehensive knowledge base and get
 
 # How to Run Test Review with TEA
 
-Use TEA's `*test-review` workflow to audit test quality with objective scoring and actionable feedback. TEA reviews tests against its knowledge base of best practices.
+Use TEA's `test-review` workflow to audit test quality with objective scoring and actionable feedback. TEA reviews tests against its knowledge base of best practices.
 
 ## When to Use This
 
@@ -30,13 +30,13 @@ Use TEA's `*test-review` workflow to audit test quality with objective scoring a
 Start a fresh chat and load TEA:
 
 ```
-*tea
+tea
 ```
 
 ### 2. Run the Test Review Workflow
 
 ```
-*test-review
+test-review
 ```
 
 ### 3. Specify Review Scope
@@ -351,17 +351,17 @@ test('should show validation error for expired card', async ({ page }) => { });
 6. Improve test names in `checkout.spec.ts`
 
 ### Long-term (Continuous Improvement)
-7. Re-run `*test-review` after fixes (target: 85/100)
+7. Re-run `test-review` after fixes (target: 85/100)
 8. Add performance budgets to CI
 9. Document test patterns for team
 
 ## Knowledge Base References
 
 TEA reviewed against these patterns:
-- [test-quality.md](/docs/reference/tea/knowledge-base.md#test-quality) - Execution limits, isolation
+- [test-quality.md](/docs/tea/reference/knowledge-base.md#test-quality) - Execution limits, isolation
-- [network-first.md](/docs/reference/tea/knowledge-base.md#network-first) - Deterministic waits
+- [network-first.md](/docs/tea/reference/knowledge-base.md#network-first) - Deterministic waits
-- [timing-debugging.md](/docs/reference/tea/knowledge-base.md#timing-debugging) - Race conditions
+- [timing-debugging.md](/docs/tea/reference/knowledge-base.md#timing-debugging) - Race conditions
-- [selector-resilience.md](/docs/reference/tea/knowledge-base.md#selector-resilience) - Robust selectors
+- [selector-resilience.md](/docs/tea/reference/knowledge-base.md#selector-resilience) - Robust selectors
 ```
 
 ## Understanding the Scores
@@ -445,8 +445,8 @@ Make test review part of release checklist:
 Always review AI-generated tests:
 
 ```
-1. Run *atdd or *automate
+1. Run atdd or automate
-2. Run *test-review on generated tests
+2. Run test-review on generated tests
 3. Fix critical issues
 4. Commit tests
 ```
@@ -585,20 +585,20 @@ Don't try to fix everything at once.
 
 ## Related Guides
 
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) - Generate tests to review
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md) - Generate tests to review
-- [How to Run Automate](/docs/how-to/workflows/run-automate.md) - Expand coverage to review
+- [How to Run Automate](/docs/tea/how-to/workflows/run-automate.md) - Expand coverage to review
-- [How to Run Trace](/docs/how-to/workflows/run-trace.md) - Coverage complements quality
+- [How to Run Trace](/docs/tea/how-to/workflows/run-trace.md) - Coverage complements quality
 
 ## Understanding the Concepts
 
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - What makes tests good
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - What makes tests good
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Avoiding flakiness
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Avoiding flakiness
-- [Fixture Architecture](/docs/explanation/tea/fixture-architecture.md) - Reusable patterns
+- [Fixture Architecture](/docs/tea/explanation/fixture-architecture.md) - Reusable patterns
 
 ## Reference
 
-- [Command: *test-review](/docs/reference/tea/commands.md#test-review) - Full command reference
+- [Command: *test-review](/docs/tea/reference/commands.md#test-review) - Full command reference
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Patterns TEA reviews against
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Patterns TEA reviews against
 
 ---
 

docs/tea/how-to/workflows/run-trace.md

@@ -5,7 +5,7 @@ description: Map requirements to tests and make quality gate decisions using TEA
 
 # How to Run Trace with TEA
 
-Use TEA's `*trace` workflow for requirements traceability and quality gate decisions. This is a two-phase workflow: Phase 1 analyzes coverage, Phase 2 makes the go/no-go decision.
+Use TEA's `trace` workflow for requirements traceability and quality gate decisions. This is a two-phase workflow: Phase 1 analyzes coverage, Phase 2 makes the go/no-go decision.
 
 ## When to Use This
 
@@ -34,7 +34,7 @@ Use TEA's `*trace` workflow for requirements traceability and quality gate decis
 ### 1. Run the Trace Workflow
 
 ```
-*trace
+trace
 ```
 
 ### 2. Specify Phase
@@ -306,7 +306,7 @@ test('should update bio via API', async ({ apiRequest, authToken }) => {
 });
 ```
 
-**Note:** `authToken` requires auth-session fixture setup. See [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md#auth-session).
+**Note:** `authToken` requires auth-session fixture setup. See [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md#auth-session).
 
 ### 2. Add Avatar Upload Tests
 
@@ -350,7 +350,7 @@ test('should accept valid image upload', async ({ request }) => {
 After reviewing traceability:
 
 1. **Fix critical gaps** - Add tests for P0/P1 requirements
-2. **Run *test-review** - Ensure new tests meet quality standards
+2. **Run `test-review`** - Ensure new tests meet quality standards
 3. **Run Phase 2** - Make gate decision after gaps addressed
 ```
 
@@ -369,7 +369,7 @@ After Phase 1 coverage analysis is complete, run Phase 2 for the gate decision.
 ### 7. Run Phase 2
 
 ```
-*trace
+trace
 ```
 
 Select "Phase 2: Quality Gate Decision"
@@ -405,12 +405,12 @@ traceability-matrix.md (from Phase 1)
 
 **Test Quality (Optional):**
 ```
-test-review.md (from *test-review)
+test-review.md (from test-review)
 ```
 
 **NFR Assessment (Optional):**
 ```
-nfr-assessment.md (from *nfr-assess)
+nfr-assessment.md (from nfr-assess)
 ```
 
 ### 10. Review Gate Decision
@@ -586,7 +586,7 @@ TEA uses deterministic rules when decision_mode = "deterministic":
 1. Add login tests (QA team, 2 days)
 2. Fix SQL injection (backend team, 1 day)
 3. Re-run security scan (DevOps, 1 hour)
-4. Re-run *trace after fixes
+4. Re-run trace after fixes
 
 **Cannot proceed until all blockers resolved.**
 ```
@@ -612,15 +612,15 @@ TEA uses deterministic rules when decision_mode = "deterministic":
 **Phase 3:**
 ```
 After architecture complete:
-1. Run *test-design (system-level)
+1. Run test-design (system-level)
-2. Run *trace Phase 1 (baseline)
+2. Run trace Phase 1 (baseline)
 3. Use for implementation-readiness gate
 ```
 
 **Phase 4:**
 ```
 After each epic/story:
-1. Run *trace Phase 1 (refresh coverage)
+1. Run trace Phase 1 (refresh coverage)
 2. Identify gaps
 3. Add missing tests
 ```
@@ -628,8 +628,8 @@ After each epic/story:
 **Release Gate:**
 ```
 Before deployment:
-1. Run *trace Phase 1 (final coverage check)
+1. Run trace Phase 1 (final coverage check)
-2. Run *trace Phase 2 (make gate decision)
+2. Run trace Phase 2 (make gate decision)
 3. Get approvals
 4. Deploy (if PASS or WAIVED)
 ```
@@ -639,7 +639,7 @@ Before deployment:
 **Phase 2:**
 ```
 Before planning new work:
-1. Run *trace Phase 1 (establish baseline)
+1. Run trace Phase 1 (establish baseline)
 2. Understand existing coverage
 3. Plan testing strategy
 ```
@@ -647,7 +647,7 @@ Before planning new work:
 **Phase 4:**
 ```
 After each epic/story:
-1. Run *trace Phase 1 (refresh)
+1. Run trace Phase 1 (refresh)
 2. Compare to baseline
 3. Track coverage improvement
 ```
@@ -655,8 +655,8 @@ After each epic/story:
 **Release Gate:**
 ```
 Before deployment:
-1. Run *trace Phase 1 (final check)
+1. Run trace Phase 1 (final check)
-2. Run *trace Phase 2 (gate decision)
+2. Run trace Phase 2 (gate decision)
 3. Compare to baseline
 4. Deploy if coverage maintained or improved
 ```
@@ -668,10 +668,10 @@ Before deployment:
 Don't wait until release gate:
 
 ```
-After Story 1: *trace Phase 1 (identify gaps early)
+After Story 1: trace Phase 1 (identify gaps early)
-After Story 2: *trace Phase 1 (refresh)
+After Story 2: trace Phase 1 (refresh)
-After Story 3: *trace Phase 1 (refresh)
+After Story 3: trace Phase 1 (refresh)
-Before Release: *trace Phase 1 + Phase 2 (final gate)
+Before Release: trace Phase 1 + Phase 2 (final gate)
 ```
 
 **Benefit:** Catch gaps early when they're cheap to fix.
@@ -864,19 +864,19 @@ Result: PARTIAL coverage (3/4 criteria)
 
 ## Related Guides
 
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md) - Provides requirements for traceability
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md) - Provides requirements for traceability
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md) - Quality scores feed gate
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md) - Quality scores feed gate
-- [How to Run NFR Assessment](/docs/how-to/workflows/run-nfr-assess.md) - NFR status feeds gate
+- [How to Run NFR Assessment](/docs/tea/how-to/workflows/run-nfr-assess.md) - NFR status feeds gate
 
 ## Understanding the Concepts
 
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - Why P0 vs P3 matters
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - Why P0 vs P3 matters
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Gate decisions in context
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Gate decisions in context
 
 ## Reference
 
-- [Command: *trace](/docs/reference/tea/commands.md#trace) - Full command reference
+- [Command: *trace](/docs/tea/reference/commands.md#trace) - Full command reference
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Config options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Config options
 
 ---
 

docs/tea/how-to/workflows/setup-ci.md

@@ -5,7 +5,7 @@ description: Configure automated test execution with selective testing and burn-
 
 # How to Set Up CI Pipeline with TEA
 
-Use TEA's `*ci` workflow to scaffold production-ready CI/CD configuration for automated test execution with selective testing, parallel sharding, and flakiness detection.
+Use TEA's `ci` workflow to scaffold production-ready CI/CD configuration for automated test execution with selective testing, parallel sharding, and flakiness detection.
 
 ## When to Use This
 
@@ -20,7 +20,7 @@ Use TEA's `*ci` workflow to scaffold production-ready CI/CD configuration for au
 
 - BMad Method installed
 - TEA agent available
-- Test framework configured (run `*framework` first)
+- Test framework configured (run `framework` first)
 - Tests written (have something to run in CI)
 - CI/CD platform access (GitHub Actions, GitLab CI, etc.)
 
@@ -31,13 +31,13 @@ Use TEA's `*ci` workflow to scaffold production-ready CI/CD configuration for au
 Start a fresh chat and load TEA:
 
 ```
-*tea
+tea
 ```
 
 ### 2. Run the CI Workflow
 
 ```
-*ci
+ci
 ```
 
 ### 3. Select CI/CD Platform
@@ -675,7 +675,7 @@ Speed up CI with caching:
 
 **Solution:**
 1. Identify flaky tests (check which iteration fails)
-2. Fix flaky tests using `*test-review`
+2. Fix flaky tests using `test-review`
 3. Re-run burn-in on specific files:
 ```bash
 npm run test:burn-in tests/flaky.spec.ts
@@ -693,19 +693,19 @@ npm run test:burn-in tests/flaky.spec.ts
 
 ## Related Guides
 
-- [How to Set Up Test Framework](/docs/how-to/workflows/setup-test-framework.md) - Run first
+- [How to Set Up Test Framework](/docs/tea/how-to/workflows/setup-test-framework.md) - Run first
-- [How to Run Test Review](/docs/how-to/workflows/run-test-review.md) - Audit CI tests
+- [How to Run Test Review](/docs/tea/how-to/workflows/run-test-review.md) - Audit CI tests
-- [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) - Burn-in utility
+- [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) - Burn-in utility
 
 ## Understanding the Concepts
 
-- [Test Quality Standards](/docs/explanation/tea/test-quality-standards.md) - Why determinism matters
+- [Test Quality Standards](/docs/tea/explanation/test-quality-standards.md) - Why determinism matters
-- [Network-First Patterns](/docs/explanation/tea/network-first-patterns.md) - Avoid CI flakiness
+- [Network-First Patterns](/docs/tea/explanation/network-first-patterns.md) - Avoid CI flakiness
 
 ## Reference
 
-- [Command: *ci](/docs/reference/tea/commands.md#ci) - Full command reference
+- [Command: *ci](/docs/tea/reference/commands.md#ci) - Full command reference
-- [TEA Configuration](/docs/reference/tea/configuration.md) - CI-related config options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - CI-related config options
 
 ---
 

docs/tea/how-to/workflows/setup-test-framework.md

@@ -3,7 +3,7 @@ title: "How to Set Up a Test Framework with TEA"
 description: How to set up a production-ready test framework using TEA
 ---
 
-Use TEA's `*framework` workflow to scaffold a production-ready test framework for your project.
+Use TEA's `framework` workflow to scaffold a production-ready test framework for your project.
 
 ## When to Use This
 
@@ -27,7 +27,7 @@ Start a fresh chat and load the TEA (Test Architect) agent.
 ### 2. Run the Framework Workflow
 
 ```
-*framework
+framework
 ```
 
 ### 3. Answer TEA's Questions
@@ -87,7 +87,7 @@ Configure in your IDE's MCP settings.
 
 - **Run only once per repository** — Framework setup is a one-time operation
 - **Run after architecture is complete** — Framework aligns with tech stack
-- **Follow up with CI setup** — Run `*ci` to configure CI/CD pipeline
+- **Follow up with CI setup** — Run `ci` to configure CI/CD pipeline
 
 ## Next Steps
 

docs/tea/reference/commands.md

@@ -9,18 +9,18 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 
 ## Quick Index
 
-- [*framework](#framework) - Scaffold test framework
+- [`framework`](#framework) - Scaffold test framework
-- [*ci](#ci) - Setup CI/CD pipeline
+- [`ci`](#ci) - Setup CI/CD pipeline
-- [*test-design](#test-design) - Risk-based test planning
+- [`test-design`](#test-design) - Risk-based test planning
-- [*atdd](#atdd) - Acceptance TDD
+- [`atdd`](#atdd) - Acceptance TDD
-- [*automate](#automate) - Test automation
+- [`automate`](#automate) - Test automation
-- [*test-review](#test-review) - Quality audit
+- [`test-review`](#test-review) - Quality audit
-- [*nfr-assess](#nfr-assess) - NFR assessment
+- [`nfr-assess`](#nfr-assess) - NFR assessment
-- [*trace](#trace) - Coverage traceability
+- [`trace`](#trace) - Coverage traceability
 
 ---
 
-## *framework
+## framework
 
 **Purpose:** Scaffold production-ready test framework (Playwright or Cypress)
 
@@ -37,11 +37,11 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 - `.env.example`, `.nvmrc`
 - Sample tests with best practices
 
-**How-To Guide:** [Setup Test Framework](/docs/how-to/workflows/setup-test-framework.md)
+**How-To Guide:** [Setup Test Framework](/docs/tea/how-to/workflows/setup-test-framework.md)
 
 ---
 
-## *ci
+## ci
 
 **Purpose:** Setup CI/CD pipeline with selective testing and burn-in
 
@@ -59,11 +59,11 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 - Burn-in loops for flakiness detection
 - Secrets checklist
 
-**How-To Guide:** [Setup CI Pipeline](/docs/how-to/workflows/setup-ci.md)
+**How-To Guide:** [Setup CI Pipeline](/docs/tea/how-to/workflows/setup-ci.md)
 
 ---
 
-## *test-design
+## test-design
 
 **Purpose:** Risk-based test planning with coverage strategy
 
@@ -108,11 +108,11 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 
 **MCP Enhancement:** Exploratory mode (live browser UI discovery)
 
-**How-To Guide:** [Run Test Design](/docs/how-to/workflows/run-test-design.md)
+**How-To Guide:** [Run Test Design](/docs/tea/how-to/workflows/run-test-design.md)
 
 ---
 
-## *atdd
+## atdd
 
 **Purpose:** Generate failing acceptance tests BEFORE implementation (TDD red phase)
 
@@ -130,11 +130,11 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 
 **MCP Enhancement:** Recording mode (for skeleton UI only - rare)
 
-**How-To Guide:** [Run ATDD](/docs/how-to/workflows/run-atdd.md)
+**How-To Guide:** [Run ATDD](/docs/tea/how-to/workflows/run-atdd.md)
 
 ---
 
-## *automate
+## automate
 
 **Purpose:** Expand test coverage after implementation
 
@@ -152,11 +152,11 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 
 **MCP Enhancement:** Healing + Recording modes (fix tests, verify selectors)
 
-**How-To Guide:** [Run Automate](/docs/how-to/workflows/run-automate.md)
+**How-To Guide:** [Run Automate](/docs/tea/how-to/workflows/run-automate.md)
 
 ---
 
-## *test-review
+## test-review
 
 **Purpose:** Audit test quality with 0-100 scoring
 
@@ -180,11 +180,11 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 - Structure: 10 points
 - Performance: 10 points
 
-**How-To Guide:** [Run Test Review](/docs/how-to/workflows/run-test-review.md)
+**How-To Guide:** [Run Test Review](/docs/tea/how-to/workflows/run-test-review.md)
 
 ---
 
-## *nfr-assess
+## nfr-assess
 
 **Purpose:** Validate non-functional requirements with evidence
 
@@ -202,11 +202,11 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 - Mitigation plans
 - Gate decision inputs
 
-**How-To Guide:** [Run NFR Assessment](/docs/how-to/workflows/run-nfr-assess.md)
+**How-To Guide:** [Run NFR Assessment](/docs/tea/how-to/workflows/run-nfr-assess.md)
 
 ---
 
-## *trace
+## trace
 
 **Purpose:** Requirements traceability + quality gate decision
 
@@ -232,7 +232,7 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 - P1 coverage: ≥90% for PASS, 80-89% for CONCERNS, <80% FAIL
 - Overall coverage: ≥80% required
 
-**How-To Guide:** [Run Trace](/docs/how-to/workflows/run-trace.md)
+**How-To Guide:** [Run Trace](/docs/tea/how-to/workflows/run-trace.md)
 
 ---
 
@@ -240,36 +240,36 @@ Quick reference for all 8 TEA (Test Architect) workflows. For detailed step-by-s
 
 | Command | Phase | Frequency | Primary Output |
 |---------|-------|-----------|----------------|
-| `*framework` | 3 | Once | Test infrastructure |
+| `framework` | 3 | Once | Test infrastructure |
-| `*ci` | 3 | Once | CI/CD pipeline |
+| `ci` | 3 | Once | CI/CD pipeline |
-| `*test-design` | 3, 4 | System + per epic | Test design doc |
+| `test-design` | 3, 4 | System + per epic | Test design doc |
-| `*atdd` | 4 | Per story (optional) | Failing tests |
+| `atdd` | 4 | Per story (optional) | Failing tests |
-| `*automate` | 4 | Per story | Passing tests |
+| `automate` | 4 | Per story | Passing tests |
-| `*test-review` | 4, Gate | Per epic/release | Quality report |
+| `test-review` | 4, Gate | Per epic/release | Quality report |
-| `*nfr-assess` | 2, Gate | Per release | NFR assessment |
+| `nfr-assess` | 2, Gate | Per release | NFR assessment |
-| `*trace` | 2, 4, Gate | Baseline + refresh + gate | Coverage matrix + decision |
+| `trace` | 2, 4, Gate | Baseline + refresh + gate | Coverage matrix + decision |
 
 ---
 
 ## See Also
 
 **How-To Guides (Detailed Instructions):**
-- [Setup Test Framework](/docs/how-to/workflows/setup-test-framework.md)
+- [Setup Test Framework](/docs/tea/how-to/workflows/setup-test-framework.md)
-- [Setup CI Pipeline](/docs/how-to/workflows/setup-ci.md)
+- [Setup CI Pipeline](/docs/tea/how-to/workflows/setup-ci.md)
-- [Run Test Design](/docs/how-to/workflows/run-test-design.md)
+- [Run Test Design](/docs/tea/how-to/workflows/run-test-design.md)
-- [Run ATDD](/docs/how-to/workflows/run-atdd.md)
+- [Run ATDD](/docs/tea/how-to/workflows/run-atdd.md)
-- [Run Automate](/docs/how-to/workflows/run-automate.md)
+- [Run Automate](/docs/tea/how-to/workflows/run-automate.md)
-- [Run Test Review](/docs/how-to/workflows/run-test-review.md)
+- [Run Test Review](/docs/tea/how-to/workflows/run-test-review.md)
-- [Run NFR Assessment](/docs/how-to/workflows/run-nfr-assess.md)
+- [Run NFR Assessment](/docs/tea/how-to/workflows/run-nfr-assess.md)
-- [Run Trace](/docs/how-to/workflows/run-trace.md)
+- [Run Trace](/docs/tea/how-to/workflows/run-trace.md)
 
 **Explanation:**
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Complete TEA lifecycle
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Complete TEA lifecycle
-- [Engagement Models](/docs/explanation/tea/engagement-models.md) - When to use which workflows
+- [Engagement Models](/docs/tea/explanation/engagement-models.md) - When to use which workflows
 
 **Reference:**
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Config options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Config options
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md) - Pattern fragments
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md) - Pattern fragments
 
 ---
 

docs/tea/reference/configuration.md

@@ -64,21 +64,21 @@ Enable Playwright Utils integration for production-ready fixtures and utilities.
 **Installer Prompt:**
 ```
 Are you using playwright-utils (@seontechnologies/playwright-utils) in your project?
-You must install packages yourself, or use test architect's *framework command.
+You must install packages yourself, or use test architect's `framework` command.
 ```
 
 **Purpose:** Enables TEA to:
-- Include playwright-utils in `*framework` scaffold
+- Include playwright-utils in `framework` scaffold
 - Generate tests using playwright-utils fixtures
 - Review tests against playwright-utils patterns
 - Configure CI with burn-in and selective testing utilities
 
 **Affects Workflows:**
-- `*framework` - Includes playwright-utils imports and fixture examples
+- `framework` - Includes playwright-utils imports and fixture examples
-- `*atdd` - Uses fixtures like `apiRequest`, `authSession` in generated tests
+- `atdd` - Uses fixtures like `apiRequest`, `authSession` in generated tests
-- `*automate` - Leverages utilities for test patterns
+- `automate` - Leverages utilities for test patterns
-- `*test-review` - Reviews against playwright-utils best practices
+- `test-review` - Reviews against playwright-utils best practices
-- `*ci` - Includes burn-in utility and selective testing
+- `ci` - Includes burn-in utility and selective testing
 
 **Example (Enable):**
 ```yaml
@@ -96,7 +96,7 @@ npm install -D @seontechnologies/playwright-utils
 ```
 
 **Related:**
-- [Integrate Playwright Utils Guide](/docs/how-to/customization/integrate-playwright-utils.md)
+- [Integrate Playwright Utils Guide](/docs/tea/how-to/customization/integrate-playwright-utils.md)
 - [Playwright Utils on npm](https://www.npmjs.com/package/@seontechnologies/playwright-utils)
 
 ---
@@ -127,9 +127,9 @@ Would you like to enable MCP enhancements in Test Architect?
 - Visual debugging and healing
 
 **Affects Workflows:**
-- `*test-design` - Enables exploratory mode (browser-based UI discovery)
+- `test-design` - Enables exploratory mode (browser-based UI discovery)
-- `*atdd` - Enables recording mode (verify selectors with live browser)
+- `atdd` - Enables recording mode (verify selectors with live browser)
-- `*automate` - Enables healing mode (fix tests with visual debugging)
+- `automate` - Enables healing mode (fix tests with visual debugging)
 
 **MCP Servers Required:**
 
@@ -173,8 +173,8 @@ tea_use_mcp_enhancements: false
 3. Browser binaries installed (`npx playwright install`)
 
 **Related:**
-- [Enable MCP Enhancements Guide](/docs/how-to/customization/enable-tea-mcp-enhancements.md)
+- [Enable MCP Enhancements Guide](/docs/tea/how-to/customization/enable-tea-mcp-enhancements.md)
-- [TEA Overview - MCP Section](/docs/explanation/features/tea-overview.md#playwright-mcp-enhancements)
+- [TEA Overview - MCP Section](/docs/tea/explanation/tea-overview.md#playwright-mcp-enhancements)
 - [Playwright MCP on npm](https://www.npmjs.com/package/@playwright/mcp)
 
 ---
@@ -197,14 +197,14 @@ output_folder: _bmad-output
 ```
 
 **TEA Output Files:**
-- `test-design-architecture.md` + `test-design-qa.md` (from *test-design system-level - TWO documents)
+- `test-design-architecture.md` + `test-design-qa.md` (from `test-design` system-level - TWO documents)
-- `test-design-epic-N.md` (from *test-design epic-level)
+- `test-design-epic-N.md` (from `test-design` epic-level)
-- `test-review.md` (from *test-review)
+- `test-review.md` (from `test-review`)
-- `traceability-matrix.md` (from *trace Phase 1)
+- `traceability-matrix.md` (from `trace` Phase 1)
-- `gate-decision-{gate_type}-{story_id}.md` (from *trace Phase 2)
+- `gate-decision-{gate_type}-{story_id}.md` (from `trace` Phase 2)
-- `nfr-assessment.md` (from *nfr-assess)
+- `nfr-assessment.md` (from `nfr-assess`)
-- `automation-summary.md` (from *automate)
+- `automation-summary.md` (from `automate`)
-- `atdd-checklist-{story_id}.md` (from *atdd)
+- `atdd-checklist-{story_id}.md` (from `atdd`)
 
 ---
 
@@ -561,7 +561,7 @@ tea_use_mcp_enhancements: true   # Recommended
 **Why recommended:**
 - Playwright Utils: Production-ready fixtures and utilities
 - MCP enhancements: Live browser verification, visual debugging
-- Together: The three-part stack (see [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md))
+- Together: The three-part stack (see [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md))
 
 **Prerequisites:**
 ```bash
@@ -660,18 +660,18 @@ document_output_language: english
 ## See Also
 
 ### How-To Guides
-- [Set Up Test Framework](/docs/how-to/workflows/setup-test-framework.md)
+- [Set Up Test Framework](/docs/tea/how-to/workflows/setup-test-framework.md)
-- [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md)
+- [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md)
-- [Enable MCP Enhancements](/docs/how-to/customization/enable-tea-mcp-enhancements.md)
+- [Enable MCP Enhancements](/docs/tea/how-to/customization/enable-tea-mcp-enhancements.md)
 
 ### Reference
-- [TEA Command Reference](/docs/reference/tea/commands.md)
+- [TEA Command Reference](/docs/tea/reference/commands.md)
-- [Knowledge Base Index](/docs/reference/tea/knowledge-base.md)
+- [Knowledge Base Index](/docs/tea/reference/knowledge-base.md)
-- [Glossary](/docs/reference/glossary/index.md)
+- [Glossary](/docs/tea/glossary/index.md)
 
 ### Explanation
-- [TEA Overview](/docs/explanation/features/tea-overview.md)
+- [TEA Overview](/docs/tea/explanation/tea-overview.md)
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md)
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md)
 
 ---
 

docs/tea/reference/knowledge-base.md

@@ -19,7 +19,7 @@ Instead of asking AI to "write good tests" every time, TEA:
 
 **Example:**
 ```
-User runs: *test-design
+User runs: `test-design`
 
 TEA reads tea-index.csv:
 - Loads: test-quality.md, test-priorities-matrix.md, risk-governance.md
@@ -31,7 +31,7 @@ Result: Focused context, consistent quality standards
 ## How Knowledge Loading Works
 
 ### 1. Workflow Trigger
-User runs a TEA workflow (e.g., `*test-design`)
+User runs a TEA workflow (e.g., `test-design`)
 
 ### 2. Manifest Lookup
 TEA reads `src/bmm/testarch/tea-index.csv`:
@@ -60,7 +60,7 @@ Core patterns for test infrastructure and fixture composition.
 | [playwright-config](../../../src/bmm/testarch/knowledge/playwright-config.md) | Environment switching, timeout standards, artifact outputs | Configuration, environments, CI |
 | [fixtures-composition](../../../src/bmm/testarch/knowledge/fixtures-composition.md) | mergeTests composition patterns for combining utilities | Fixture merging, utility composition |
 
-**Used in:** `*framework`, `*test-design`, `*atdd`, `*automate`, `*test-review`
+**Used in:** `framework`, `test-design`, `atdd`, `automate`, `test-review`
 
 ---
 
@@ -74,7 +74,7 @@ Patterns for test data generation, authentication, and setup.
 | [email-auth](../../../src/bmm/testarch/knowledge/email-auth.md) | Magic link extraction, state preservation, negative flows | Authentication, email testing |
 | [auth-session](../../../src/bmm/testarch/knowledge/auth-session.md) | Token persistence, multi-user, API/browser authentication | Auth patterns, session management |
 
-**Used in:** `*framework`, `*atdd`, `*automate`, `*test-review`
+**Used in:** `framework`, `atdd`, `automate`, `test-review`
 
 ---
 
@@ -89,7 +89,7 @@ Network interception, error handling, and reliability patterns.
 | [error-handling](../../../src/bmm/testarch/knowledge/error-handling.md) | Scoped exception handling, retry validation, telemetry logging | Error patterns, resilience |
 | [network-error-monitor](../../../src/bmm/testarch/knowledge/network-error-monitor.md) | HTTP 4xx/5xx detection for UI tests | Error detection, monitoring |
 
-**Used in:** `*atdd`, `*automate`, `*test-review`
+**Used in:** `atdd`, `automate`, `test-review`
 
 ---
 
@@ -103,7 +103,7 @@ CI/CD patterns, burn-in testing, and selective test execution.
 | [burn-in](../../../src/bmm/testarch/knowledge/burn-in.md) | Smart test selection, git diff for CI optimization | Test selection, performance |
 | [selective-testing](../../../src/bmm/testarch/knowledge/selective-testing.md) | Tag/grep usage, spec filters, diff-based runs | Test filtering, optimization |
 
-**Used in:** `*ci`, `*test-review`
+**Used in:** `ci`, `test-review`
 
 ---
 
@@ -119,7 +119,7 @@ Test quality standards, test level selection, and TDD patterns.
 | [test-healing-patterns](../../../src/bmm/testarch/knowledge/test-healing-patterns.md) | Common failure patterns and automated fixes | Debugging, healing, fixes |
 | [component-tdd](../../../src/bmm/testarch/knowledge/component-tdd.md) | Red→green→refactor workflow, provider isolation | TDD, component testing |
 
-**Used in:** `*test-design`, `*atdd`, `*automate`, `*test-review`, `*trace`
+**Used in:** `test-design`, `atdd`, `automate`, `test-review`, `trace`
 
 ---
 
@@ -133,7 +133,7 @@ Risk assessment, governance, and gate decision frameworks.
 | [probability-impact](../../../src/bmm/testarch/knowledge/probability-impact.md) | Probability × impact scale for scoring matrix | Risk scoring, impact analysis |
 | [nfr-criteria](../../../src/bmm/testarch/knowledge/nfr-criteria.md) | Security, performance, reliability, maintainability status | NFRs, compliance, enterprise |
 
-**Used in:** `*test-design`, `*nfr-assess`, `*trace`
+**Used in:** `test-design`, `nfr-assess`, `trace`
 
 ---
 
@@ -147,7 +147,7 @@ Selector resilience, race condition debugging, and visual debugging.
 | [timing-debugging](../../../src/bmm/testarch/knowledge/timing-debugging.md) | Race condition identification and deterministic fixes | Race conditions, timing issues |
 | [visual-debugging](../../../src/bmm/testarch/knowledge/visual-debugging.md) | Trace viewer usage, artifact expectations | Debugging, trace viewer, artifacts |
 
-**Used in:** `*atdd`, `*automate`, `*test-review`
+**Used in:** `atdd`, `automate`, `test-review`
 
 ---
 
@@ -161,7 +161,7 @@ Feature flag testing, contract testing, and API testing patterns.
 | [contract-testing](../../../src/bmm/testarch/knowledge/contract-testing.md) | Pact publishing, provider verification, resilience | Contract testing, Pact |
 | [api-testing-patterns](../../../src/bmm/testarch/knowledge/api-testing-patterns.md) | Pure API patterns without browser | API testing, backend testing |
 
-**Used in:** `*test-design`, `*atdd`, `*automate`
+**Used in:** `test-design`, `atdd`, `automate`
 
 ---
 
@@ -183,7 +183,7 @@ Patterns for using `@seontechnologies/playwright-utils` package (9 utilities).
 
 **Note:** `fixtures-composition` is listed under Architecture & Fixtures (general Playwright `mergeTests` pattern, applies to all fixtures).
 
-**Used in:** `*framework` (if `tea_use_playwright_utils: true`), `*atdd`, `*automate`, `*test-review`, `*ci`
+**Used in:** `framework` (if `tea_use_playwright_utils: true`), `atdd`, `automate`, `test-review`, `ci`
 
 **Official Docs:** <https://seontechnologies.github.io/playwright-utils/>
 
@@ -219,7 +219,7 @@ risk-governance,Risk Governance,Risk scoring and gate decisions,risk;governance,
 
 Each TEA workflow loads specific fragments:
 
-### *framework
+### `framework`
 **Key Fragments:**
 - fixture-architecture.md
 - playwright-config.md
@@ -231,7 +231,7 @@ Each TEA workflow loads specific fragments:
 
 ---
 
-### *test-design
+### `test-design`
 **Key Fragments:**
 - test-quality.md
 - test-priorities-matrix.md
@@ -245,7 +245,7 @@ Each TEA workflow loads specific fragments:
 
 ---
 
-### *atdd
+### `atdd`
 **Key Fragments:**
 - test-quality.md
 - component-tdd.md
@@ -262,7 +262,7 @@ Each TEA workflow loads specific fragments:
 
 ---
 
-### *automate
+### `automate`
 **Key Fragments:**
 - test-quality.md
 - test-levels-framework.md
@@ -279,7 +279,7 @@ Each TEA workflow loads specific fragments:
 
 ---
 
-### *test-review
+### `test-review`
 **Key Fragments:**
 - test-quality.md
 - test-healing-patterns.md
@@ -296,7 +296,7 @@ Each TEA workflow loads specific fragments:
 
 ---
 
-### *ci
+### `ci`
 **Key Fragments:**
 - ci-burn-in.md
 - burn-in.md
@@ -307,7 +307,7 @@ Each TEA workflow loads specific fragments:
 
 ---
 
-### *nfr-assess
+### `nfr-assess`
 **Key Fragments:**
 - nfr-criteria.md
 - risk-governance.md
@@ -317,7 +317,7 @@ Each TEA workflow loads specific fragments:
 
 ---
 
-### *trace
+### `trace`
 **Key Fragments:**
 - test-priorities-matrix.md
 - risk-governance.md
@@ -331,9 +331,9 @@ Each TEA workflow loads specific fragments:
 
 ## Related
 
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - How knowledge base fits in TEA
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - How knowledge base fits in TEA
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - Context engineering philosophy
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - Context engineering philosophy
-- [TEA Command Reference](/docs/reference/tea/commands.md) - Workflows that use fragments
+- [TEA Command Reference](/docs/tea/reference/commands.md) - Workflows that use fragments
 
 ---
 

docs/tea/tutorials/tea-lite-quickstart.md

@@ -3,7 +3,7 @@ title: "Getting Started with Test Architect"
 description: Learn Test Architect fundamentals by generating and running tests for an existing demo app in 30 minutes
 ---
 
-Welcome! **Test Architect (TEA) Lite** is the simplest way to get started with TEA - just use `*automate` to generate tests for existing features. Perfect for beginners who want to learn TEA fundamentals quickly.
+Welcome! **Test Architect (TEA) Lite** is the simplest way to get started with TEA - just use the `automate` workflow (e.g., `/automate` in Claude Code) to generate tests for existing features. Perfect for beginners who want to learn TEA fundamentals quickly.
 
 ## What You'll Build
 
@@ -19,14 +19,14 @@ By the end of this 30-minute tutorial, you'll have:
 :::
 
 :::tip[Quick Path]
-Load TEA (`*tea`) → scaffold framework (`*framework`) → create test plan (`*test-design`) → generate tests (`*automate`) → run with `npx playwright test`.
+Load TEA (`tea`) → scaffold framework (`framework`) → create test plan (`test-design`) → generate tests (`automate`) → run with `npx playwright test`.
 :::
 
 ## TEA Approaches Explained
 
 Before we start, understand the three ways to use TEA:
 
-- **TEA Lite** (this tutorial): Beginner using just `*automate` to test existing features
+- **TEA Lite** (this tutorial): Beginner using just the `automate` workflow to test existing features
 - **TEA Solo**: Using TEA standalone without full BMad Method integration
 - **TEA Integrated**: Full BMad Method with all TEA workflows across phases
 
@@ -68,7 +68,7 @@ BMad is now installed! You'll see a `_bmad/` folder in your project.
 Start a new chat with your AI assistant (Claude, etc.) and type:
 
 ```
-*tea
+tea
 ```
 
 This loads the Test Architect agent. You'll see TEA's menu with available workflows.
@@ -78,7 +78,7 @@ This loads the Test Architect agent. You'll see TEA's menu with available workfl
 In your chat, run:
 
 ```
-*framework
+framework
 ```
 
 TEA will ask you questions:
@@ -120,7 +120,7 @@ Test design is where TEA shines - risk-based planning before writing tests.
 In your chat with TEA, run:
 
 ```
-*test-design
+test-design
 ```
 
 **Q: System-level or epic-level?**
@@ -161,7 +161,7 @@ Now the magic happens - TEA generates tests based on your test design.
 In your chat with TEA, run:
 
 ```
-*automate
+automate
 ```
 
 **Q: What are you testing?**
@@ -280,7 +280,7 @@ test('should mark todo as complete', async ({ page, apiRequest }) => {
 - Built-in schema validation
 - Cleaner, more maintainable code
 
-See [Integrate Playwright Utils](/docs/how-to/customization/integrate-playwright-utils.md) to enable this.
+See [Integrate Playwright Utils](/docs/tea/how-to/customization/integrate-playwright-utils.md) to enable this.
 
 ## Step 4: Run and Validate (5 minutes)
 
@@ -319,9 +319,9 @@ Opens a beautiful HTML report showing:
 ### What Just Happened?
 
 You used **TEA Lite** to:
-1. Scaffold a production-ready test framework (`*framework`)
+1. Scaffold a production-ready test framework (`framework`)
-2. Create a risk-based test plan (`*test-design`)
+2. Create a risk-based test plan (`test-design`)
-3. Generate comprehensive tests (`*automate`)
+3. Generate comprehensive tests (`automate`)
 4. Run tests against an existing application
 
 All in 30 minutes!
@@ -334,10 +334,10 @@ Congratulations! You've completed the TEA Lite tutorial. You learned:
 
 | Command        | Purpose                              |
 | -------------- | ------------------------------------ |
-| `*tea`         | Load the TEA agent                   |
+| `tea`          | Load the TEA agent                   |
-| `*framework`   | Scaffold test infrastructure         |
+| `framework`    | Scaffold test infrastructure         |
-| `*test-design` | Risk-based test planning             |
+| `test-design`  | Risk-based test planning             |
-| `*automate`    | Generate tests for existing features |
+| `automate`     | Generate tests for existing features |
 
 ### TEA Principles
 - **Risk-based testing** - Depth scales with impact (P0 vs P3)
@@ -346,44 +346,44 @@ Congratulations! You've completed the TEA Lite tutorial. You learned:
 - **Production-ready from day one** - Not toy examples
 
 :::tip[Key Takeaway]
-TEA Lite (just `*automate`) is perfect for beginners learning TEA fundamentals, testing existing applications, quick test coverage expansion, and teams wanting fast results.
+TEA Lite (just `automate`) is perfect for beginners learning TEA fundamentals, testing existing applications, quick test coverage expansion, and teams wanting fast results.
 :::
 
 ## Understanding ATDD vs Automate
 
-This tutorial used `*automate` to generate tests for **existing features** (tests pass immediately).
+This tutorial used the `automate` workflow to generate tests for **existing features** (tests pass immediately).
 
-**When to use `*automate`:**
+**When to use `automate`:**
 - Feature already exists
 - Want to add test coverage
 - Tests should pass on first run
 
-**When to use `*atdd` (Acceptance Test-Driven Development):**
+**When to use `atdd` (Acceptance Test-Driven Development):**
 - Feature doesn't exist yet (Test-Driven Development workflow)
 - Want failing tests BEFORE implementation
 - Following red → green → refactor cycle
 
-See [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) for the test-drive development (TDD) approach.
+See [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md) for the test-drive development (TDD) approach.
 
 ## Next Steps
 
 ### Level Up Your TEA Skills
 
 **How-To Guides** (task-oriented):
-- [How to Run Test Design](/docs/how-to/workflows/run-test-design.md) - Deep dive into risk assessment
+- [How to Run Test Design](/docs/tea/how-to/workflows/run-test-design.md) - Deep dive into risk assessment
-- [How to Run ATDD](/docs/how-to/workflows/run-atdd.md) - Generate failing tests first (TDD)
+- [How to Run ATDD](/docs/tea/how-to/workflows/run-atdd.md) - Generate failing tests first (TDD)
-- [How to Set Up CI Pipeline](/docs/how-to/workflows/setup-ci.md) - Automate test execution
+- [How to Set Up CI Pipeline](/docs/tea/how-to/workflows/setup-ci.md) - Automate test execution
-- [How to Review Test Quality](/docs/how-to/workflows/run-test-review.md) - Audit test quality
+- [How to Review Test Quality](/docs/tea/how-to/workflows/run-test-review.md) - Audit test quality
 
 **Explanation** (understanding-oriented):
-- [TEA Overview](/docs/explanation/features/tea-overview.md) - Complete TEA capabilities
+- [TEA Overview](/docs/tea/explanation/tea-overview.md) - Complete TEA capabilities
-- [Testing as Engineering](/docs/explanation/philosophy/testing-as-engineering.md) - **Why TEA exists** (problem + solution)
+- [Testing as Engineering](/docs/tea/explanation/testing-as-engineering.md) - **Why TEA exists** (problem + solution)
-- [Risk-Based Testing](/docs/explanation/tea/risk-based-testing.md) - How risk scoring works
+- [Risk-Based Testing](/docs/tea/explanation/risk-based-testing.md) - How risk scoring works
 
 **Reference** (quick lookup):
-- [TEA Command Reference](/docs/reference/tea/commands.md) - All 8 TEA workflows
+- [TEA Command Reference](/docs/tea/reference/commands.md) - All 8 TEA workflows
-- [TEA Configuration](/docs/reference/tea/configuration.md) - Config options
+- [TEA Configuration](/docs/tea/reference/configuration.md) - Config options
-- [Glossary](/docs/reference/glossary/index.md) - TEA terminology
+- [Glossary](/docs/tea/glossary/index.md) - TEA terminology
 
 ### Try TEA Solo
 
@@ -392,14 +392,14 @@ Ready for standalone usage without full BMad Method? Use TEA Solo:
 - Bring your own requirements
 - Use on non-BMad projects
 
-See [TEA Overview](/docs/explanation/features/tea-overview.md) for engagement models.
+See [TEA Overview](/docs/tea/explanation/tea-overview.md) for engagement models.
 
 ### Go Full TEA Integrated
 
 Want the complete quality operating model? Try TEA Integrated with BMad Method:
 - Phase 2: Planning with non-functional requirements (NFR) assessment
 - Phase 3: Architecture testability review
-- Phase 4: Per-epic test design → ATDD → automate
+- Phase 4: Per-epic test design → `atdd` → `automate`
 - Release Gate: Coverage traceability and gate decisions
 
 See [BMad Method Documentation](/) for the full workflow.

docs/tutorials/getting-started.md

@@ -1,12 +1,8 @@
 ---
-title: "Getting Started with the BMad Method"
+title: "Getting Started"
 description: Install BMad and build your first project
 ---
 
-**Upgrading from previous versions?** See the [Upgrade Guide](/docs/how-to/installation/upgrade-to-v6.md) instead.
-
----
-
 Build software faster using AI-powered workflows with specialized agents that guide you through planning, architecture, and implementation.
 
 ## What You'll Learn
@@ -25,10 +21,9 @@ Build software faster using AI-powered workflows with specialized agents that gu
 
 :::tip[Quick Path]
 **Install** → `npx bmad-method@alpha install`
-**Initialize** → Load Analyst agent, run `workflow-init`
 **Plan** → PM creates PRD, Architect creates architecture
 **Build** → SM manages sprints, DEV implements stories
-**Always use fresh chats** for each workflow to avoid context issues.
+**Fresh chats** for each workflow to avoid context issues.
 :::
 
 ## Understanding BMad
@@ -42,7 +37,7 @@ BMad helps you build software through guided workflows with specialized AI agent
 | 3     | Solutioning    | Design architecture *(BMad Method/Enterprise only)* |
 | 4     | Implementation | Build epic by epic, story by story                  |
 
-**[Open the Interactive Workflow Guide](/workflow-guide)** to explore phases, agents, and outputs for your chosen track.
+**[Open the Workflow Map](/docs/reference/workflow-map.md)** to explore phases, workflows, and context management.
 
 Based on your project's complexity, BMad offers three planning tracks:
 
@@ -64,68 +59,38 @@ Open a terminal in your project directory and run:
 npx bmad-method@alpha install
 ```
 
-The interactive installer guides you through setup and creates a `_bmad/` folder with all agents and workflows.
+When prompted to select modules, choose **BMad Method**.
 
-Verify your installation:
+The installer creates two folders:
+- `_bmad/` — agents, workflows, tasks, and configuration
+- `_bmad-output/` — empty for now, but this is where your artifacts will be saved
 
-```
+Open your AI IDE in the project folder. Run the `help` workflow (`/bmad-help` on most platforms) to see what to do next — it detects what you've completed and recommends the next step.
-your-project/
-├── _bmad/
-│   ├── bmm/            # Method module
-│   │   ├── agents/     # Agent files
-│   │   ├── workflows/  # Workflow files
-│   │   └── config.yaml # Module config
-│   └── core/           # Core utilities
-├── _bmad-output/       # Generated artifacts (created later)
-└── .claude/            # IDE configuration (if using Claude Code)
-```
-
-:::tip[Troubleshooting]
-Having issues? See [Install BMad](/docs/how-to/installation/install-bmad.md) for common solutions.
-:::
-
-Open your AI IDE in the project folder. From here, you can run `/bmad-help` anytime to see what to do next — or ask it a question like `/bmad-help How should I build a web app for XYZ?`
-
-## Step 1: Initialize Your Project
-
-Load the **Analyst agent** in your IDE, wait for the menu, then run `workflow-init`.
-
-:::note[How to Load Agents]
-Type `/<agent-name>` in your IDE and use autocomplete. Not sure what's available? Start with `/bmad` to see all agents and workflows.
-:::
-
-The workflow asks you to describe your project, whether it's new or existing, and the general complexity. Based on your description, it recommends a planning track.
-
-Once you confirm, the workflow creates `bmm-workflow-status.yaml` to track your progress through all phases.
 
 :::caution[Fresh Chats]
 Always start a fresh chat for each workflow. This prevents context limitations from causing issues.
 :::
 
-## Step 2: Create Your Plan
+## Step 1: Create Your Plan
 
-After initialization, work through phases 1-3. **Use fresh chats for each workflow.**
+Work through phases 1-3. **Use fresh chats for each workflow.**
-
-:::tip[Check Your Status]
-Unsure what's next? Load any agent and ask for `workflow-status`. It tells you the next recommended or required workflow.
-:::
 
 ### Phase 1: Analysis (Optional)
 
 All workflows in this phase are optional:
-- **brainstorm-project** — Guided ideation
+- **brainstorming** — Guided ideation
 - **research** — Market and technical research
-- **product-brief** — Recommended foundation document
+- **create-product-brief** — Recommended foundation document
 
 ### Phase 2: Planning (Required)
 
 **For BMad Method and Enterprise tracks:**
 1. Load the **PM agent** in a new chat
-2. Run the PRD workflow: `*prd`
+2. Run the `prd` workflow
 3. Output: `PRD.md`
 
 **For Quick Flow track:**
-- Use `tech-spec` instead of PRD, then skip to implementation
+- Use the `quick-spec` workflow instead of PRD, then skip to implementation
 
 :::note[UX Design (Optional)]
 If your project has a user interface, load the **UX-Designer agent** and run the UX design workflow after creating your PRD.
@@ -150,10 +115,10 @@ Epics and stories are now created *after* architecture. This produces better qua
 
 **Implementation Readiness Check** *(Highly Recommended)*
 1. Load the **Architect agent** in a new chat
-2. Run `implementation-readiness`
+2. Run `check-implementation-readiness`
 3. Validates cohesion across all planning documents
 
-## Step 3: Build Your Project
+## Step 2: Build Your Project
 
 Once planning is complete, move to implementation. **Each workflow should run in a fresh chat.**
 
@@ -169,8 +134,7 @@ For each story, repeat this cycle with fresh chats:
 | ---- | ----- | -------------- | ------------------------------------- |
 | 1    | SM    | `create-story` | Create story file from epic           |
 | 2    | DEV   | `dev-story`    | Implement the story                   |
-| 3    | TEA   | `automate`     | Generate guardrail tests *(optional)* |
+| 3    | DEV   | `code-review`  | Quality validation *(recommended)*    |
-| 4    | DEV   | `code-review`  | Quality validation *(recommended)*    |
 
 After completing all stories in an epic, load the **SM agent** and run `retrospective`.
 
@@ -192,25 +156,23 @@ your-project/
 │   ├── PRD.md                     # Your requirements document
 │   ├── architecture.md            # Technical decisions
 │   ├── epics/                     # Epic and story files
-│   ├── bmm-workflow-status.yaml   # Phase progress tracking
 │   └── sprint-status.yaml         # Sprint tracking
 └── ...
 ```
 
 ## Quick Reference
 
-| Command                     | Agent     | Purpose                              |
+| Workflow                           | Agent     | Purpose                              |
-| --------------------------- | --------- | ------------------------------------ |
+| ---------------------------------- | --------- | ------------------------------------ |
-| `*workflow-init`            | Analyst   | Initialize a new project             |
+| `help`                             | Any       | Get guidance on what to do next      |
-| `*workflow-status`          | Any       | Check progress and next steps        |
+| `prd`                              | PM        | Create Product Requirements Document |
-| `*prd`                      | PM        | Create Product Requirements Document |
+| `create-architecture`              | Architect | Create architecture document         |
-| `*create-architecture`      | Architect | Create architecture document         |
+| `create-epics-and-stories`         | PM        | Break down PRD into epics            |
-| `*create-epics-and-stories` | PM        | Break down PRD into epics            |
+| `check-implementation-readiness`   | Architect | Validate planning cohesion           |
-| `*implementation-readiness` | Architect | Validate planning cohesion           |
+| `sprint-planning`                  | SM        | Initialize sprint tracking           |
-| `*sprint-planning`          | SM        | Initialize sprint tracking           |
+| `create-story`                     | SM        | Create a story file                  |
-| `*create-story`             | SM        | Create a story file                  |
+| `dev-story`                        | DEV       | Implement a story                    |
-| `*dev-story`                | DEV       | Implement a story                    |
+| `code-review`                      | DEV       | Review implemented code              |
-| `*code-review`              | DEV       | Review implemented code              |
 
 ## Common Questions
 
@@ -221,26 +183,23 @@ Only for BMad Method and Enterprise tracks. Quick Flow skips from tech-spec to i
 Yes. The SM agent has a `correct-course` workflow for handling scope changes.
 
 **What if I want to brainstorm first?**
-Load the Analyst agent and run `brainstorm-project` before `workflow-init`.
+Load the Analyst agent and run `brainstorming` before starting your PRD.
 
-**Can I skip workflow-init and workflow-status?**
+**Do I need to follow a strict order?**
-Yes, once you learn the flow. Use the Quick Reference to go directly to needed workflows.
+Not strictly. Once you learn the flow, you can run workflows directly using the Quick Reference above.
 
 ## Getting Help
 
 - **During workflows** — Agents guide you with questions and explanations
 - **Community** — [Discord](https://discord.gg/gk8jAdXWmj) (#bmad-method-help, #report-bugs-and-issues)
-- **Documentation** — [BMM Workflow Reference](/docs/reference/workflows/index.md)
+- **Stuck?** — Run `help` to see what to do next
-- **Video tutorials** — [BMad Code YouTube](https://www.youtube.com/@BMadCode)
 
 ## Key Takeaways
 
 :::tip[Remember These]
-- **Always use fresh chats** — Load agents in new chats for each workflow
+- **Always use fresh chats** — Start a new chat for each workflow
-- **Let workflow-status guide you** — Ask any agent for status when unsure
+- **Track matters** — Quick Flow uses quick-spec; Method/Enterprise need PRD and architecture
-- **Track matters** — Quick Flow uses tech-spec; Method/Enterprise need PRD and architecture
+- **Use `help` when stuck** — It detects your progress and suggests next steps
-- **Tracking is automatic** — Status files update themselves
-- **Agents are flexible** — Use menu numbers, shortcuts (`*prd`), or natural language
 :::
 
-Ready to start? Install BMad, load the Analyst, run `workflow-init`, and let the agents guide you.
+Ready to start? Install BMad and let the agents guide you through your first project.

src/bmm/workflows/3-solutioning/check-implementation-readiness/steps/step-01-document-discovery.md

@@ -3,7 +3,7 @@ name: 'step-01-document-discovery'
 description: 'Discover and inventory all project documents, handling duplicates and organizing file structure'
 
 # Path Definitions
-workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness'
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/implementation-readiness'
 
 # File References
 thisStepFile: './step-01-document-discovery.md'

src/bmm/workflows/3-solutioning/check-implementation-readiness/steps/step-02-prd-analysis.md

@@ -3,7 +3,7 @@ name: 'step-02-prd-analysis'
 description: 'Read and analyze PRD to extract all FRs and NFRs for coverage validation'
 
 # Path Definitions
-workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness'
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/implementation-readiness'
 
 # File References
 thisStepFile: './step-02-prd-analysis.md'

src/bmm/workflows/3-solutioning/check-implementation-readiness/steps/step-03-epic-coverage-validation.md

@@ -3,7 +3,7 @@ name: 'step-03-epic-coverage-validation'
 description: 'Validate that all PRD FRs are covered in epics and stories'
 
 # Path Definitions
-workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness'
+workflow_path: '{project-root}/_bmad/bmm/workflows/3-solutioning/implementation-readiness'
 
 # File References
 thisStepFile: './step-03-epic-coverage-validation.md'