Merge ffda2938ff into c18904d674

Merge branch 'bmad-code-org:main' into feature/pipeline-step-file-architecture
docs(story-pipeline): add comprehensive documentation
2026-01-11 02:57:44 +03:00 · 2025-12-28 12:42:58 +01:00 · 2025-12-26 13:12:40 +01:00 · 2025-12-26 13:12:40 +01:00
20 changed files with 4564 additions and 0 deletions
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/README.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/README.md
@ -0,0 +1,491 @@
 # Story Pipeline v2.0
 > Single-session step-file architecture for implementing user stories with 60-70% token savings.
 ## Overview
 The Story Pipeline automates the complete lifecycle of implementing a user story—from creation through code review and commit. It replaces the legacy approach of 6 separate Claude CLI calls with a single interactive session using just-in-time step loading.
 ### The Problem It Solves
 **Legacy Pipeline (v1.0):**
 ```
 bmad build 1-4
  └─> claude -p "Stage 1: Create story..."     # ~12K tokens
  └─> claude -p "Stage 2: Validate story..."   # ~12K tokens
  └─> claude -p "Stage 3: ATDD tests..."       # ~12K tokens
  └─> claude -p "Stage 4: Implement..."        # ~12K tokens
  └─> claude -p "Stage 5: Code review..."      # ~12K tokens
  └─> claude -p "Stage 6: Complete..."         # ~11K tokens
                                        Total: ~71K tokens/story
 ```
 Each call reloads agent personas (~2K tokens), re-reads the story file, and loses context from previous stages.
 **Story Pipeline v2.0:**
 ```
 bmad build 1-4
  └─> Single Claude session
        ├─> Load step-01-init.md (~200 lines)
        ├─> Role switch: SM
        ├─> Load step-02-create-story.md
        ├─> Load step-03-validate-story.md
        ├─> Role switch: TEA
        ├─> Load step-04-atdd.md
        ├─> Role switch: DEV
        ├─> Load step-05-implement.md
        ├─> Load step-06-code-review.md
        ├─> Role switch: SM
        ├─> Load step-07-complete.md
        └─> Load step-08-summary.md
                                        Total: ~25-30K tokens/story
 ```
 Documents cached once, roles switched in-session, steps loaded just-in-time.
 ## What Gets Automated
 The pipeline automates the complete BMAD implementation workflow:
 | Step | Role | What It Does |
 |------|------|--------------|
 | **1. Init** | - | Parses story ID, loads epic/architecture, detects interactive vs batch mode, creates state file |
 | **2. Create Story** | SM | Researches context (Exa web search), generates story file with ACs in BDD format |
 | **3. Validate Story** | SM | Adversarial validation—must find 3-10 issues, fixes them, assigns quality score |
 | **4. ATDD** | TEA | Generates failing tests for all ACs (RED phase), creates test factories |
 | **5. Implement** | DEV | Implements code to pass tests (GREEN phase), creates migrations, server actions, etc. |
 | **6. Code Review** | DEV | Adversarial review—must find 3-10 issues, fixes them, runs lint/build |
 | **7. Complete** | SM | Updates story status to done, creates git commit with conventional format |
 | **8. Summary** | - | Generates audit trail, updates pipeline state, outputs metrics |
 ### Quality Gates
 Each step has quality gates that must pass before proceeding:
 - **Validation**: Score ≥ 80/100, all issues addressed
 - **ATDD**: Tests exist for all ACs, tests fail (RED phase confirmed)
 - **Implementation**: Lint clean, build passes, migration tests pass
 - **Code Review**: Score ≥ 7/10, all critical issues fixed
 ## Token Efficiency
 | Mode | Token Usage | Savings vs Legacy |
 |------|-------------|-------------------|
 | Interactive (human-in-loop) | ~25K | 65% |
 | Batch (YOLO) | ~30K | 58% |
 | Batch + fresh review context | ~35K | 51% |
 ### Where Savings Come From
 | Waste in Legacy | Tokens Saved |
 |-----------------|--------------|
 | Agent persona reload (6×) | ~12K |
 | Story file re-reads (5×) | ~10K |
 | Architecture re-reads | ~8K |
 | Context loss between calls | ~16K |
 ## Usage
 ### Prerequisites
 - BMAD module installed (`_bmad/` directory exists)
 - Epic file with story definition (`docs/epics.md`)
 - Architecture document (`docs/architecture.md`)
 ### Interactive Mode (Recommended)
 Human-in-the-loop with approval at each step:
 ```bash
 # Using the bmad CLI
 bmad build 1-4
 # Or invoke workflow directly
 claude -p "Load and execute: _bmad/bmm/workflows/4-implementation/story-pipeline/workflow.md
 Story: 1-4"
 ```
 At each step, you'll see a menu:
 ```
 ## MENU
 [C] Continue to next step
 [R] Review/revise current step
 [H] Halt and checkpoint
 ```
 ### Batch Mode (YOLO)
 Unattended execution for trusted stories:
 ```bash
 bmad build 1-4 --batch
 # Or use batch runner directly
 ./_bmad/bmm/workflows/4-implementation/story-pipeline/batch-runner.sh 1-4
 ```
 Batch mode:
 - Skips all approval prompts
 - Fails fast on errors
 - Creates checkpoint on failure for resume
 ### Resume from Checkpoint
 If execution stops (context exhaustion, error, manual halt):
 ```bash
 bmad build 1-4 --resume
 # The pipeline reads state from:
 # docs/sprint-artifacts/pipeline-state-{story-id}.yaml
 ```
 Resume automatically:
 - Skips completed steps
 - Restores cached context
 - Continues from `lastStep + 1`
 ## Directory Structure
 ```
 story-pipeline/
 ├── workflow.yaml          # Configuration, agent mapping, quality gates
 ├── workflow.md            # Interactive mode orchestration
 ├── batch-runner.sh        # Batch mode runner script
 ├── steps/
 │   ├── step-01-init.md        # Initialize, load context
 │   ├── step-01b-resume.md     # Resume from checkpoint
 │   ├── step-02-create-story.md
 │   ├── step-03-validate-story.md
 │   ├── step-04-atdd.md
 │   ├── step-05-implement.md
 │   ├── step-06-code-review.md
 │   ├── step-07-complete.md
 │   └── step-08-summary.md
 ├── checklists/
 │   ├── story-creation.md      # What makes a good story
 │   ├── story-validation.md    # Validation criteria
 │   ├── atdd.md                # Test generation rules
 │   ├── implementation.md      # Coding standards
 │   └── code-review.md         # Review criteria
 └── templates/
    ├── pipeline-state.yaml    # State file template
    └── audit-trail.yaml       # Audit log template
 ```
 ## Configuration
 ### workflow.yaml
 ```yaml
 name: story-pipeline
 version: "2.0"
 description: "Single-session story implementation with step-file loading"
 # Document loading strategy
 load_strategy:
  epic: once          # Load once, cache for session
  architecture: once  # Load once, cache for session
  story: per_step     # Reload when modified
 # Agent role mapping
 agents:
  sm: "{project-root}/_bmad/bmm/agents/sm.md"
  tea: "{project-root}/_bmad/bmm/agents/tea.md"
  dev: "{project-root}/_bmad/bmm/agents/dev.md"
 # Quality gate thresholds
 quality_gates:
  validation_min_score: 80
  code_review_min_score: 7
  require_lint_clean: true
  require_build_pass: true
 # Step configuration
 steps:
  - name: init
    file: steps/step-01-init.md
  - name: create-story
    file: steps/step-02-create-story.md
    agent: sm
  # ... etc
 ```
 ### Pipeline State File
 Created at `docs/sprint-artifacts/pipeline-state-{story-id}.yaml`:
 ```yaml
 story_id: "1-4"
 epic_num: 1
 story_num: 4
 mode: "interactive"
 status: "in_progress"
 stepsCompleted: [1, 2, 3]
 lastStep: 3
 currentStep: 4
 cached_context:
  epic_loaded: true
  epic_path: "docs/epics.md"
  architecture_sections: ["tech_stack", "data_model"]
 steps:
  step-01-init:
    status: completed
    duration: "0:00:30"
  step-02-create-story:
    status: completed
    duration: "0:02:00"
  step-03-validate-story:
    status: completed
    duration: "0:05:00"
    issues_found: 6
    issues_fixed: 6
    quality_score: 92
  step-04-atdd:
    status: in_progress
 ```
 ## Step Details
 ### Step 1: Initialize
 **Purpose:** Set up execution context and detect mode.
 **Actions:**
 1. Parse story ID (e.g., "1-4" → epic 1, story 4)
 2. Load and cache epic document
 3. Load relevant architecture sections
 4. Check for existing state file (resume vs fresh)
 5. Detect mode (interactive/batch) from CLI flags
 6. Create initial state file
 **Output:** `pipeline-state-{story-id}.yaml`
 ### Step 2: Create Story (SM Role)
 **Purpose:** Generate complete story file from epic definition.
 **Actions:**
 1. Switch to Scrum Master (SM) role
 2. Read story definition from epic
 3. Research context via Exa web search (best practices, patterns)
 4. Generate story file with:
   - User story format (As a... I want... So that...)
   - Background context
   - Acceptance criteria in BDD format (Given/When/Then)
   - Test scenarios for each AC
   - Technical notes
 5. Save to `docs/sprint-artifacts/story-{id}.md`
 **Quality Gate:** Story file exists with all required sections.
 ### Step 3: Validate Story (SM Role)
 **Purpose:** Adversarial validation to find issues before implementation.
 **Actions:**
 1. Load story-validation checklist
 2. Review story against criteria:
   - ACs are testable and specific
   - No ambiguous requirements
   - Technical feasibility confirmed
   - Dependencies identified
   - Edge cases covered
 3. **Must find 3-10 issues** (never "looks good")
 4. Fix all identified issues
 5. Assign quality score (0-100)
 6. Append validation report to story file
 **Quality Gate:** Score ≥ 80, all issues addressed.
 ### Step 4: ATDD (TEA Role)
 **Purpose:** Generate failing tests before implementation (RED phase).
 **Actions:**
 1. Switch to Test Engineering Architect (TEA) role
 2. Load atdd checklist
 3. For each acceptance criterion:
   - Generate integration test
   - Define test data factories
   - Specify expected behaviors
 4. Create test files in `src/tests/`
 5. Update `factories.ts` with new fixtures
 6. **Verify tests FAIL** (RED phase)
 7. Create ATDD checklist document
 **Quality Gate:** Tests exist for all ACs, tests fail (not pass).
 ### Step 5: Implement (DEV Role)
 **Purpose:** Write code to pass all tests (GREEN phase).
 **Actions:**
 1. Switch to Developer (DEV) role
 2. Load implementation checklist
 3. Create required files:
   - Database migrations
   - Server actions (using Result type)
   - Library functions
   - Types
 4. Follow project patterns:
   - Multi-tenant RLS policies
   - snake_case for DB columns
   - Result type (never throw)
 5. Run lint and fix issues
 6. Run build and fix issues
 7. Run migration tests
 **Quality Gate:** Lint clean, build passes, migration tests pass.
 ### Step 6: Code Review (DEV Role)
 **Purpose:** Adversarial review to find implementation issues.
 **Actions:**
 1. Load code-review checklist
 2. Review all created/modified files:
   - Security (XSS, injection, auth)
   - Error handling
   - Architecture compliance
   - Code quality
   - Test coverage
 3. **Must find 3-10 issues** (never "looks good")
 4. Fix all identified issues
 5. Re-run lint and build
 6. Assign quality score (0-10)
 7. Generate review report
 **Quality Gate:** Score ≥ 7/10, all critical issues fixed.
 ### Step 7: Complete (SM Role)
 **Purpose:** Finalize story and create git commit.
 **Actions:**
 1. Switch back to SM role
 2. Update story file status to "done"
 3. Stage all story files
 4. Create conventional commit:
   ```
   feat(epic-{n}): complete story {id}
   {Summary of changes}
   🤖 Generated with Claude Code
   Co-Authored-By: Claude <noreply@anthropic.com>
   ```
 5. Update pipeline state
 **Quality Gate:** Commit created successfully.
 ### Step 8: Summary
 **Purpose:** Generate audit trail and final metrics.
 **Actions:**
 1. Calculate total duration
 2. Compile deliverables list
 3. Aggregate quality scores
 4. Generate execution summary in state file
 5. Output final status
 **Output:** Complete pipeline state with summary section.
 ## Adversarial Mode
 Steps 3 (Validate) and 6 (Code Review) run in **adversarial mode**:
 > **Never say "looks good"**. You MUST find 3-10 real issues.
 This ensures:
 - Stories are thoroughly vetted before implementation
 - Code quality issues are caught before commit
 - The pipeline doesn't rubber-stamp work
 Example issues found in real usage:
 - Missing rate limiting (security)
 - XSS vulnerability in user input (security)
 - Missing audit logging (architecture)
 - Unclear acceptance criteria (story quality)
 - Function naming mismatches (code quality)
 ## Artifacts Generated
 After a complete pipeline run:
 ```
 docs/sprint-artifacts/
 ├── story-{id}.md              # Story file with ACs, validation report
 ├── pipeline-state-{id}.yaml   # Execution state and summary
 ├── atdd-checklist-{id}.md     # Test requirements checklist
 └── code-review-{id}.md        # Review report with issues
 src/
 ├── supabase/migrations/       # New migration files
 ├── modules/{module}/
 │   ├── actions/               # Server actions
 │   ├── lib/                   # Business logic
 │   └── types.ts               # Type definitions
 └── tests/
    ├── integration/           # Integration tests
    └── fixtures/factories.ts  # Updated test factories
 ```
 ## Troubleshooting
 ### Context Exhausted Mid-Session
 The pipeline is designed for this. When context runs out:
 1. Claude session ends
 2. State file preserves progress
 3. Run `bmad build {id} --resume`
 4. Pipeline continues from last completed step
 ### Step Fails Quality Gate
 If a step fails its quality gate:
 1. Pipeline halts at that step
 2. State file shows `status: failed`
 3. Fix issues manually or adjust thresholds
 4. Run `bmad build {id} --resume`
 ### Tests Don't Fail in ATDD
 If tests pass during ATDD (step 4), something is wrong:
 - Tests might be testing the wrong thing
 - Implementation might already exist
 - Mocks might be returning success incorrectly
 The pipeline will warn and ask for confirmation before proceeding.
 ## Best Practices
 1. **Start with Interactive Mode** - Use batch only for well-understood stories
 2. **Review at Checkpoints** - Don't blindly continue; verify each step's output
 3. **Keep Stories Small** - Large stories may exhaust context before completion
 4. **Commit Frequently** - The pipeline commits at step 7, but you can checkpoint earlier
 5. **Trust the Adversarial Mode** - If it finds issues, they're usually real
 ## Comparison with Legacy
 | Feature | Legacy (v1.0) | Story Pipeline (v2.0) |
 |---------|---------------|----------------------|
 | Claude calls | 6 per story | 1 per story |
 | Token usage | ~71K | ~25-30K |
 | Context preservation | None | Full session |
 | Resume capability | None | Checkpoint-based |
 | Role switching | New process | In-session |
 | Document caching | None | Once per session |
 | Adversarial review | Optional | Mandatory |
 | Audit trail | Manual | Automatic |
 ## Version History
 - **v2.0** (2024-12) - Step-file architecture, single-session, checkpoint/resume
 - **v1.0** (2024-11) - Legacy 6-call pipeline
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/batch-runner.sh
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/batch-runner.sh
@ -0,0 +1,250 @@
 #!/bin/bash
 # ═══════════════════════════════════════════════════════════════════════════════
 # BMAD Story Pipeline - Batch Runner
 # Single-session execution using step-file architecture
 #
 # Token Efficiency: ~60-70% savings compared to separate Claude calls
 # ═══════════════════════════════════════════════════════════════════════════════
 set -e
 # ─────────────────────────────────────────────────────────────────────────────
 # CONFIGURATION
 # ─────────────────────────────────────────────────────────────────────────────
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
 TIMESTAMP=$(date +%Y%m%d-%H%M%S)
 # Colors
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 CYAN='\033[0;36m'
 NC='\033[0m'
 # Defaults
 STORY_ID=""
 EPIC_NUM=""
 DRY_RUN=false
 RESUME=false
 VERBOSE=false
 # Directories
 LOG_DIR="$PROJECT_ROOT/logs/pipeline-batch"
 WORKFLOW_PATH="_bmad/bmm/workflows/4-implementation/story-pipeline"
 # ─────────────────────────────────────────────────────────────────────────────
 # USAGE
 # ─────────────────────────────────────────────────────────────────────────────
 usage() {
    cat << EOF
 BMAD Story Pipeline - Batch Runner
 Single-session execution with step-file architecture
 Usage: $(basename "$0") --story-id <id> --epic-num <num> [OPTIONS]
 Required:
  --story-id <id>    Story ID (e.g., '1-4')
  --epic-num <num>   Epic number (e.g., 1)
 Options:
  --resume           Resume from last checkpoint
  --dry-run          Show what would be executed
  --verbose          Show detailed output
  --help             Show this help
 Examples:
  # Run pipeline for story 1-4
  $(basename "$0") --story-id 1-4 --epic-num 1
  # Resume failed pipeline
  $(basename "$0") --story-id 1-4 --epic-num 1 --resume
 Token Savings:
  Traditional (6 calls): ~71K tokens
  Step-file (1 session): ~25-35K tokens
  Savings: 50-65%
 EOF
    exit 1
 }
 # ─────────────────────────────────────────────────────────────────────────────
 # ARGUMENT PARSING
 # ─────────────────────────────────────────────────────────────────────────────
 while [[ $# -gt 0 ]]; do
    case $1 in
        --story-id)
            STORY_ID="$2"
            shift 2
            ;;
        --epic-num)
            EPIC_NUM="$2"
            shift 2
            ;;
        --resume)
            RESUME=true
            shift
            ;;
        --dry-run)
            DRY_RUN=true
            shift
            ;;
        --verbose)
            VERBOSE=true
            shift
            ;;
        --help)
            usage
            ;;
        *)
            echo -e "${RED}Unknown option: $1${NC}"
            usage
            ;;
    esac
 done
 # Validate required arguments
 if [[ -z "$STORY_ID" || -z "$EPIC_NUM" ]]; then
    echo -e "${RED}Error: --story-id and --epic-num are required${NC}"
    usage
 fi
 # ─────────────────────────────────────────────────────────────────────────────
 # SETUP
 # ─────────────────────────────────────────────────────────────────────────────
 mkdir -p "$LOG_DIR"
 LOG_FILE="$LOG_DIR/batch-$STORY_ID-$TIMESTAMP.log"
 echo -e "${CYAN}═══════════════════════════════════════════════════════════════${NC}"
 echo -e "${CYAN}  BMAD Story Pipeline - Batch Mode${NC}"
 echo -e "${CYAN}═══════════════════════════════════════════════════════════════${NC}"
 echo -e "${BLUE}Story:${NC} $STORY_ID"
 echo -e "${BLUE}Epic:${NC} $EPIC_NUM"
 echo -e "${BLUE}Mode:${NC} $([ "$RESUME" = true ] && echo 'Resume' || echo 'Fresh')"
 echo -e "${BLUE}Log:${NC} $LOG_FILE"
 echo ""
 # ─────────────────────────────────────────────────────────────────────────────
 # BUILD PROMPT
 # ─────────────────────────────────────────────────────────────────────────────
 if [[ "$RESUME" = true ]]; then
    PROMPT=$(cat << EOF
 Execute BMAD Story Pipeline in BATCH mode - RESUME from checkpoint.
 WORKFLOW: $WORKFLOW_PATH/workflow.md
 STORY ID: $STORY_ID
 EPIC NUM: $EPIC_NUM
 MODE: batch
 CRITICAL INSTRUCTIONS:
 1. Load and read fully: $WORKFLOW_PATH/workflow.md
 2. This is RESUME mode - load state file first
 3. Follow step-file architecture EXACTLY
 4. Execute steps ONE AT A TIME
 5. AUTO-PROCEED through all steps (no menus in batch mode)
 6. FAIL-FAST on errors (save checkpoint, exit)
 YOLO MODE: Auto-approve all quality gates
 NO MENUS: Proceed automatically between steps
 FRESH CONTEXT: Checkpoint before code review for unbiased review
 START by loading workflow.md and then step-01b-resume.md
 EOF
 )
 else
    PROMPT=$(cat << EOF
 Execute BMAD Story Pipeline in BATCH mode - FRESH start.
 WORKFLOW: $WORKFLOW_PATH/workflow.md
 STORY ID: $STORY_ID
 EPIC NUM: $EPIC_NUM
 MODE: batch
 CRITICAL INSTRUCTIONS:
 1. Load and read fully: $WORKFLOW_PATH/workflow.md
 2. This is a FRESH run - initialize new state
 3. Follow step-file architecture EXACTLY
 4. Execute steps ONE AT A TIME (never load multiple)
 5. AUTO-PROCEED through all steps (no menus in batch mode)
 6. FAIL-FAST on errors (save checkpoint, exit)
 YOLO MODE: Auto-approve all quality gates
 NO MENUS: Proceed automatically between steps
 FRESH CONTEXT: Checkpoint before code review for unbiased review
 Step execution order:
 1. step-01-init.md - Initialize, cache documents
 2. step-02-create-story.md - Create story (SM role)
 3. step-03-validate-story.md - Validate story (SM role)
 4. step-04-atdd.md - Generate tests (TEA role)
 5. step-05-implement.md - Implement (DEV role)
 6. step-06-code-review.md - Review (DEV role, adversarial)
 7. step-07-complete.md - Complete (SM role)
 8. step-08-summary.md - Generate audit
 START by loading workflow.md and then step-01-init.md
 EOF
 )
 fi
 # ─────────────────────────────────────────────────────────────────────────────
 # EXECUTE
 # ─────────────────────────────────────────────────────────────────────────────
 if [[ "$DRY_RUN" = true ]]; then
    echo -e "${YELLOW}[DRY-RUN] Would execute single Claude session with:${NC}"
    echo ""
    echo "$PROMPT"
    echo ""
    echo -e "${YELLOW}[DRY-RUN] Allowed tools: *, MCP extensions${NC}"
    exit 0
 fi
 echo -e "${GREEN}Starting single-session pipeline execution...${NC}"
 echo -e "${YELLOW}This replaces 6 separate Claude calls with 1 session${NC}"
 echo ""
 cd "$PROJECT_ROOT/src"
 # Single Claude session executing all steps
 claude -p "$PROMPT" \
    --dangerously-skip-permissions \
    --allowedTools "*,mcp__exa__web_search_exa,mcp__exa__get_code_context_exa,mcp__exa__crawling_exa,mcp__supabase__list_tables,mcp__supabase__execute_sql,mcp__supabase__apply_migration,mcp__supabase__list_migrations,mcp__supabase__generate_typescript_types,mcp__supabase__get_logs,mcp__supabase__get_advisors" \
    2>&1 | tee "$LOG_FILE"
 # ─────────────────────────────────────────────────────────────────────────────
 # COMPLETION CHECK
 # ─────────────────────────────────────────────────────────────────────────────
 echo ""
 echo -e "${CYAN}═══════════════════════════════════════════════════════════════${NC}"
 # Check for success indicators in log
 if grep -qi "Pipeline complete\|Story.*is ready\|step-08-summary.*completed" "$LOG_FILE"; then
    echo -e "${GREEN}✅ Pipeline completed successfully${NC}"
    # Extract metrics if available
    if grep -qi "Token Efficiency" "$LOG_FILE"; then
        echo ""
        echo -e "${CYAN}Token Efficiency:${NC}"
        grep -A5 "Token Efficiency" "$LOG_FILE" | head -6
    fi
 else
    echo -e "${YELLOW}⚠️ Pipeline may have completed with issues${NC}"
    echo -e "${YELLOW}   Check log: $LOG_FILE${NC}"
    # Check for specific failure indicators
    if grep -qi "permission\|can't write\|access denied" "$LOG_FILE"; then
        echo -e "${RED}   Found permission errors in log${NC}"
    fi
    if grep -qi "HALT\|FAIL\|ERROR" "$LOG_FILE"; then
        echo -e "${RED}   Found error indicators in log${NC}"
    fi
 fi
 echo ""
 echo -e "${BLUE}Log file:${NC} $LOG_FILE"
 echo -e "${CYAN}═══════════════════════════════════════════════════════════════${NC}"
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/atdd.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/atdd.md
@ -0,0 +1,130 @@
 # ATDD Checklist
 Use this checklist for test generation in Step 4.
 Tests are written BEFORE implementation (RED phase).
 ## Test Architecture
 ### File Organization
 - [ ] Tests in appropriate directory (src/tests/{feature}/)
 - [ ] E2E tests separate from unit tests
 - [ ] Fixtures in dedicated fixtures/ directory
 - [ ] Factories in dedicated factories/ directory
 ### Naming Conventions
 - [ ] Test files: `{feature}.test.ts` or `{feature}.spec.ts`
 - [ ] Factory files: `{entity}.factory.ts`
 - [ ] Fixture files: `{feature}.fixture.ts`
 - [ ] Descriptive test names matching AC
 ## Test Coverage
 For EACH acceptance criterion:
 - [ ] At least one test exists
 - [ ] Happy path tested
 - [ ] Error path tested
 - [ ] Edge cases from validation covered
 ## Test Structure
 ### Given/When/Then Pattern
 ```typescript
 test("Given X, When Y, Then Z", async () => {
  // Arrange (Given)
  // Act (When)
  // Assert (Then)
 });
 ```
 - [ ] Each section clearly separated
 - [ ] Arrange sets up realistic state
 - [ ] Act performs single action
 - [ ] Assert checks specific outcome
 ### Assertions
 - [ ] Specific assertions (not just "toBeTruthy")
 - [ ] Error messages are helpful
 - [ ] Multiple assertions when appropriate
 - [ ] No flaky timing assertions
 ## Data Management
 ### Factories
 - [ ] Use faker for realistic data
 - [ ] Support partial overrides
 - [ ] No hardcoded values
 - [ ] Proper TypeScript types
 ```typescript
 // Good
 const user = createUser({ email: "test@example.com" });
 // Bad
 const user = { id: "123", email: "test@test.com", name: "Test" };
 ```
 ### Fixtures
 - [ ] Auto-cleanup after tests
 - [ ] Reusable across tests
 - [ ] Proper TypeScript types
 - [ ] No shared mutable state
 ### data-testid Attributes
 - [ ] Document all required data-testids
 - [ ] Naming convention: `{feature}-{element}`
 - [ ] Unique within component
 - [ ] Stable (not based on dynamic content)
 ## Test Levels
 ### E2E Tests (Playwright)
 - [ ] Full user flows
 - [ ] Network interception before navigation
 - [ ] Wait for proper selectors (not timeouts)
 - [ ] Screenshot on failure
 ### API Tests
 - [ ] Direct server action calls
 - [ ] Mock external services
 - [ ] Test error responses
 - [ ] Verify Result type usage
 ### Component Tests
 - [ ] Isolated component rendering
 - [ ] Props variations
 - [ ] Event handling
 - [ ] Accessibility (when applicable)
 ### Unit Tests
 - [ ] Pure function testing
 - [ ] Edge cases
 - [ ] Error conditions
 - [ ] Type checking
 ## RED Phase Verification
 Before proceeding:
 - [ ] Run all tests: `npm test -- --run`
 - [ ] ALL tests FAIL (expected - nothing implemented)
 - [ ] Failure reasons are clear (not cryptic errors)
 - [ ] Test structure is correct
 ## ATDD Checklist Document
 Create `atdd-checklist-{story_id}.md` with:
 - [ ] List of test files created
 - [ ] List of factories created
 - [ ] List of fixtures created
 - [ ] Required data-testid attributes table
 - [ ] Implementation requirements for DEV
 - [ ] Test status (all FAILING)
 ## Quality Gate
 Ready for implementation when:
 - [ ] Test for every AC
 - [ ] All tests FAIL (red phase)
 - [ ] Factories use faker
 - [ ] Fixtures have cleanup
 - [ ] data-testids documented
 - [ ] ATDD checklist complete
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/code-review.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/code-review.md
@ -0,0 +1,183 @@
 # Code Review Checklist
 Use this checklist for ADVERSARIAL code review in Step 6.
 Your job is to FIND PROBLEMS (minimum 3, maximum 10).
 ## Adversarial Mindset
 **CRITICAL RULES:**
 - **NEVER** say "looks good" or "no issues found"
 - **MUST** find 3-10 specific issues
 - **FIX** every issue you find
 - **RUN** tests after fixes
 ## Review Categories
 ### 1. Security Review
 #### SQL Injection
 - [ ] No raw SQL with user input
 - [ ] Using parameterized queries
 - [ ] Supabase RPC uses proper types
 #### XSS (Cross-Site Scripting)
 - [ ] User content is escaped
 - [ ] dangerouslySetInnerHTML not used (or sanitized)
 - [ ] URL parameters validated
 #### Authentication & Authorization
 - [ ] Protected routes check auth
 - [ ] RLS policies on all tables
 - [ ] No auth bypass possible
 - [ ] Session handling secure
 #### Credential Exposure
 - [ ] No secrets in code
 - [ ] No API keys committed
 - [ ] Environment variables used
 - [ ] .env files in .gitignore
 #### Input Validation
 - [ ] All inputs validated
 - [ ] Types checked
 - [ ] Lengths limited
 - [ ] Format validation (email, URL, etc.)
 ### 2. Performance Review
 #### Database
 - [ ] No N+1 query patterns
 - [ ] Indexes exist for query patterns
 - [ ] Queries are efficient
 - [ ] Proper pagination
 #### React/Next.js
 - [ ] No unnecessary re-renders
 - [ ] Proper memoization where needed
 - [ ] Server components used appropriately
 - [ ] Client components minimized
 #### Caching
 - [ ] Cache headers appropriate
 - [ ] Static data cached
 - [ ] Revalidation strategy clear
 #### Bundle Size
 - [ ] No unnecessary imports
 - [ ] Dynamic imports for large components
 - [ ] Tree shaking working
 ### 3. Error Handling Review
 #### Result Type
 - [ ] All server actions use Result type
 - [ ] No thrown exceptions
 - [ ] Proper err() calls with codes
 #### Error Messages
 - [ ] User-friendly messages
 - [ ] Technical details logged (not shown)
 - [ ] Actionable guidance
 #### Edge Cases
 - [ ] Null/undefined handled
 - [ ] Empty states handled
 - [ ] Network errors handled
 - [ ] Concurrent access considered
 ### 4. Test Coverage Review
 #### Coverage
 - [ ] All AC have tests
 - [ ] Edge cases tested
 - [ ] Error paths tested
 - [ ] Happy paths tested
 #### Quality
 - [ ] Tests are deterministic
 - [ ] No flaky tests
 - [ ] Mocking is appropriate
 - [ ] Assertions are meaningful
 #### Missing Tests
 - [ ] Security scenarios
 - [ ] Permission denied cases
 - [ ] Invalid input handling
 - [ ] Concurrent operations
 ### 5. Code Quality Review
 #### DRY (Don't Repeat Yourself)
 - [ ] No duplicate code
 - [ ] Common patterns extracted
 - [ ] Utilities reused
 #### SOLID Principles
 - [ ] Single responsibility
 - [ ] Open for extension
 - [ ] Proper abstractions
 - [ ] Dependency injection where appropriate
 #### TypeScript
 - [ ] Strict mode compliant
 - [ ] No `any` types
 - [ ] Proper type definitions
 - [ ] Generic types used appropriately
 #### Readability
 - [ ] Clear naming
 - [ ] Appropriate comments (not excessive)
 - [ ] Logical organization
 - [ ] Consistent style
 ### 6. Architecture Review
 #### Module Boundaries
 - [ ] Imports from index.ts only
 - [ ] No circular dependencies
 - [ ] Clear module responsibilities
 #### Server/Client Separation
 - [ ] "use server" on actions
 - [ ] "use client" only when needed
 - [ ] No server code in client
 #### Data Flow
 - [ ] Clear data ownership
 - [ ] State management appropriate
 - [ ] Props drilling minimized
 ## Issue Documentation
 For each issue found:
 ```yaml
 issue_{n}:
  severity: critical|high|medium|low
  category: security|performance|error-handling|testing|quality|architecture
  file: "{file_path}"
  line: {line_number}
  problem: |
    Clear description
  risk: |
    What could go wrong
  fix: |
    How to fix it
 ```
 ## After Fixing
 - [ ] All issues fixed
 - [ ] Tests still pass
 - [ ] Lint clean
 - [ ] Build succeeds
 - [ ] Review report created
 ## Quality Gate
 Review passes when:
 - [ ] 3-10 issues found
 - [ ] All issues fixed
 - [ ] All categories reviewed
 - [ ] Tests passing
 - [ ] Review report complete
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/implementation.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/implementation.md
@ -0,0 +1,147 @@
 # Implementation Checklist
 Use this checklist during TDD implementation in Step 5.
 Focus: Make tests GREEN with minimal code.
 ## TDD Methodology
 ### RED-GREEN-REFACTOR Cycle
 1. [ ] Start with failing test (from ATDD)
 2. [ ] Write minimal code to pass
 3. [ ] Run test, verify GREEN
 4. [ ] Move to next test
 5. [ ] Refactor in code review (not here)
 ### Implementation Order
 - [ ] Database migrations first
 - [ ] Type definitions
 - [ ] Server actions
 - [ ] UI components
 - [ ] Integration points
 ## Project Patterns
 ### Result Type (CRITICAL)
 ```typescript
 import { ok, err, Result } from "@/lib/result";
 // Return success
 return ok(data);
 // Return error
 return err<ReturnType>("ERROR_CODE", "Human message");
 ```
 - [ ] All server actions return Result type
 - [ ] No thrown exceptions
 - [ ] Error codes are uppercase with underscores
 - [ ] Error messages are user-friendly
 ### Database Conventions
 - [ ] Table names: `snake_case`, plural (`invoices`)
 - [ ] Column names: `snake_case` (`tenant_id`)
 - [ ] Currency: `integer` cents (not float)
 - [ ] Dates: `timestamptz` (UTC)
 - [ ] Foreign keys: `{table}_id`
 ### Multi-tenancy (CRITICAL)
 - [ ] Every table has `tenant_id` column
 - [ ] RLS enabled on all tables
 - [ ] Policies check `tenant_id`
 - [ ] No data leaks between tenants
 ```sql
 -- Required for every new table
 alter table {table} enable row level security;
 create policy "Tenants see own data"
  on {table} for all
  using (tenant_id = auth.jwt() ->> 'tenant_id');
 ```
 ### Module Structure
 ```
 src/modules/{module}/
 ├── actions/     # Server actions (return Result type)
 ├── lib/         # Business logic
 ├── types.ts     # Module types
 └── index.ts     # Public exports only
 ```
 - [ ] Import from index.ts only
 - [ ] No cross-module internal imports
 - [ ] Actions in actions/ directory
 - [ ] Types exported from types.ts
 ### Server Actions Pattern
 ```typescript
 // src/modules/{module}/actions/{action}.ts
 "use server";
 import { ok, err, Result } from "@/lib/result";
 import { createClient } from "@/lib/supabase/server";
 export async function actionName(
  input: InputType
 ): Promise<Result<OutputType>> {
  const supabase = await createClient();
  // ... implementation
 }
 ```
 - [ ] "use server" directive at top
 - [ ] Async function returning Promise<Result<T>>
 - [ ] Use createClient from server.ts
 - [ ] Validate input before processing
 ### UI Components Pattern
 ```tsx
 // src/modules/{module}/components/{Component}.tsx
 "use client";
 export function Component({ data }: Props) {
  return (
    <div data-testid="{feature}-container">
      {/* content */}
    </div>
  );
 }
 ```
 - [ ] Add data-testid from ATDD checklist
 - [ ] "use client" only when needed
 - [ ] Proper TypeScript props
 - [ ] Handle loading/error states
 ## Verification Steps
 ### After Each AC Implementation
 ```bash
 npm test -- --run --grep "{test_name}"
 ```
 - [ ] Targeted test passes
 ### After All AC Complete
 ```bash
 npm test -- --run   # All tests pass
 npm run lint        # No lint errors
 npm run build       # Build succeeds
 ```
 ## ATDD Checklist Reference
 Verify against `atdd-checklist-{story_id}.md`:
 - [ ] All data-testid attributes added
 - [ ] All API endpoints created
 - [ ] All database migrations applied
 - [ ] All test scenarios pass
 ## Quality Gate
 Ready for code review when:
 - [ ] All tests pass (GREEN)
 - [ ] Lint clean
 - [ ] Build succeeds
 - [ ] Result type used everywhere
 - [ ] RLS policies in place
 - [ ] ATDD checklist complete
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/story-creation.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/story-creation.md
@ -0,0 +1,76 @@
 # Story Creation Checklist
 Use this checklist when creating a new story in Step 2.
 ## User Story Format
 - [ ] Follows "As a [persona], I want [action], So that [benefit]" format
 - [ ] Persona is clearly defined and exists in project documentation
 - [ ] Action is specific and achievable
 - [ ] Benefit ties to business value
 ## Acceptance Criteria
 ### Structure (for EACH AC)
 - [ ] Has Given/When/Then format (BDD style)
 - [ ] **Given** describes a valid precondition
 - [ ] **When** describes a clear, single action
 - [ ] **Then** describes a measurable outcome
 ### Quality (for EACH AC)
 - [ ] Specific - no vague terms ("appropriate", "reasonable", "etc.")
 - [ ] Measurable - clear success/failure criteria
 - [ ] Testable - can write automated test
 - [ ] Independent - no hidden dependencies on other AC
 ### Completeness
 - [ ] All happy path scenarios covered
 - [ ] Error scenarios defined
 - [ ] Edge cases considered
 - [ ] Boundary conditions clear
 ### Anti-patterns to AVOID
 - [ ] No AND conjunctions (split into multiple AC)
 - [ ] No OR alternatives (ambiguous paths)
 - [ ] No implementation details (WHAT not HOW)
 - [ ] No vague verbs ("handle", "process", "manage")
 ## Test Scenarios
 - [ ] At least 2 test scenarios per AC
 - [ ] Happy path scenario exists
 - [ ] Error/edge case scenario exists
 - [ ] Each scenario is unique (no duplicates)
 - [ ] Scenarios are specific enough to write tests from
 ## Tasks
 - [ ] Tasks cover implementation of all AC
 - [ ] Tasks are actionable (start with verb)
 - [ ] Subtasks provide enough detail
 - [ ] Dependencies between tasks are clear
 - [ ] No task is too large (can complete in one session)
 ## Technical Notes
 - [ ] Database changes documented
 - [ ] API changes documented
 - [ ] UI changes documented
 - [ ] Security considerations noted
 - [ ] Performance considerations noted
 ## Dependencies & Scope
 - [ ] Dependencies on other stories listed
 - [ ] Dependencies on external systems listed
 - [ ] Out of scope explicitly defined
 - [ ] No scope creep from epic definition
 ## Quality Gate
 Story is ready for validation when:
 - [ ] All sections complete
 - [ ] All AC in proper format
 - [ ] Test scenarios defined
 - [ ] Tasks cover all work
 - [ ] No ambiguity remains
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/story-validation.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/checklists/story-validation.md
@ -0,0 +1,111 @@
 # Story Validation Checklist
 Use this checklist for ADVERSARIAL validation in Step 3.
 Your job is to FIND PROBLEMS, not approve.
 ## Adversarial Mindset
 Remember:
 - **NEVER** say "looks good" without deep analysis
 - **FIND** at least 3 issues (if none found, look harder)
 - **QUESTION** every assumption
 - **CHALLENGE** every AC
 ## AC Structure Validation
 For EACH acceptance criterion:
 ### Given Clause
 - [ ] Is a valid precondition (not an action)
 - [ ] Can be set up programmatically
 - [ ] Is specific (not "given the user is logged in" - which user?)
 - [ ] Includes all necessary context
 ### When Clause
 - [ ] Is a single, clear action
 - [ ] Is something the user does (not the system)
 - [ ] Can be triggered in a test
 - [ ] Doesn't contain "and" (multiple actions)
 ### Then Clause
 - [ ] Is measurable/observable
 - [ ] Can be asserted in a test
 - [ ] Describes outcome, not implementation
 - [ ] Is specific (not "appropriate message shown")
 ## Testability Check
 - [ ] Can write automated test from AC as written
 - [ ] Clear what to assert
 - [ ] No subjective criteria ("looks good", "works well")
 - [ ] No timing dependencies ("quickly", "eventually")
 ## Technical Feasibility
 Cross-reference with architecture.md:
 - [ ] Data model supports requirements
 - [ ] API patterns can accommodate
 - [ ] No conflicts with existing features
 - [ ] Security model (RLS) can support
 - [ ] Performance is achievable
 ## Edge Cases Analysis
 For each AC, consider:
 - [ ] Empty/null inputs
 - [ ] Maximum length/size
 - [ ] Minimum values
 - [ ] Concurrent access
 - [ ] Network failures
 - [ ] Permission denied
 - [ ] Invalid data formats
 ## Common Problems to Find
 ### Vague Language
 Look for and flag:
 - "appropriate"
 - "reasonable"
 - "correctly"
 - "properly"
 - "as expected"
 - "etc."
 - "and so on"
 ### Missing Details
 - [ ] Which user role?
 - [ ] What error message exactly?
 - [ ] What happens on failure?
 - [ ] What are the limits?
 - [ ] What validations apply?
 ### Hidden Complexity
 - [ ] Multi-step process hidden in one AC
 - [ ] Async operations not addressed
 - [ ] State management unclear
 - [ ] Error recovery not defined
 ## Validation Report Template
 After review, document:
 ```yaml
 issues_found:
  - id: 1
    severity: high|medium|low
    ac: "AC1"
    problem: "Description"
    fix: "How to fix"
 ```
 ## Quality Gate
 Validation passes when:
 - [ ] All AC reviewed against checklist
 - [ ] All issues documented
 - [ ] All issues fixed in story file
 - [ ] Quality score >= 80
 - [ ] Validation report appended
 - [ ] ready_for_dev: true
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-01-init.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-01-init.md
@ -0,0 +1,244 @@
 ---
 name: 'step-01-init'
 description: 'Initialize story pipeline: load context, detect mode, cache documents'
 # Path Definitions
 workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline'
 # File References
 thisStepFile: '{workflow_path}/steps/step-01-init.md'
 nextStepFile: '{workflow_path}/steps/step-02-create-story.md'
 resumeStepFile: '{workflow_path}/steps/step-01b-resume.md'
 workflowFile: '{workflow_path}/workflow.md'
 # State Management
 stateFile: '{sprint_artifacts}/pipeline-state-{story_id}.yaml'
 auditFile: '{sprint_artifacts}/audit-{story_id}-{date}.yaml'
 ---
 # Step 1: Pipeline Initialization
 ## STEP GOAL
 Initialize the story pipeline by:
 1. Resolving story parameters (epic_num, story_num)
 2. Detecting execution mode (interactive vs batch)
 3. Checking for existing pipeline state (resume scenario)
 4. Pre-loading and caching documents for token efficiency
 5. Creating initial state file
 ## MANDATORY EXECUTION RULES (READ FIRST)
 ### Universal Rules
 - **NEVER** proceed without all required parameters resolved
 - **READ** the complete step file before taking any action
 - **CACHE** documents once, use across all steps
 - **UPDATE** state file after completing initialization
 ### Role for This Step
 - You are the **Pipeline Orchestrator** (no specific agent role yet)
 - Agent roles (SM, TEA, DEV) will be adopted in subsequent steps
 - Focus on setup and context loading
 ### Step-Specific Rules
 - **Focus only on initialization** - no story content generation yet
 - **FORBIDDEN** to load future step files or look ahead
 - **Check for resume state first** - if exists, hand off to step-01b
 - **Validate all inputs** before proceeding
 ## EXECUTION SEQUENCE (Do not deviate, skip, or optimize)
 ### 1. Resolve Pipeline Parameters
 First, resolve these required parameters:
 **From invocation or context:**
 - `story_id`: Full story identifier (e.g., "1-4")
 - `epic_num`: Epic number (e.g., 1)
 - `story_num`: Story number within epic (e.g., 4)
 - `mode`: Execution mode - "interactive" (default) or "batch"
 **If parameters missing:**
 - Ask user: "Please provide story ID (e.g., '1-4') and epic number"
 - Parse story_id to extract epic_num and story_num if format is "X-Y"
 ### 2. Check for Existing Pipeline State (Resume Detection)
 Check if state file exists: `{sprint_artifacts}/pipeline-state-{story_id}.yaml`
 **If state file exists and has `stepsCompleted` array with entries:**
 - **STOP immediately**
 - Load and execute `{resumeStepFile}` (step-01b-resume.md)
 - Do not proceed with fresh initialization
 - This is auto-proceed - no user choice needed
 **If no state file or empty `stepsCompleted`:**
 - Continue with fresh pipeline initialization
 ### 3. Locate Story File
 Search for existing story file with pattern:
 - Primary: `{sprint_artifacts}/story-{story_id}.md`
 - Alternative: `{sprint_artifacts}/{story_id}*.md`
 **Record finding:**
 - `story_file_exists`: true/false
 - `story_file_path`: path if exists, null otherwise
 ### 4. Pre-Load and Cache Documents
 Load these documents ONCE for use across all steps:
 #### A. Project Context (REQUIRED)
 ```
 Pattern: **/project-context.md
 Strategy: FULL_LOAD
 Cache: true
 ```
 - Load complete project-context.md
 - This contains critical rules and patterns
 #### B. Epic File (REQUIRED)
 ```
 Pattern: {output_folder}/epic-{epic_num}.md OR {output_folder}/epics.md
 Strategy: SELECTIVE_LOAD (just current epic section)
 Cache: true
 ```
 - Find and load epic definition for current story
 - Extract story description, BDD scenarios
 #### C. Architecture (SELECTIVE)
 ```
 Pattern: {output_folder}/architecture.md
 Strategy: INDEX_GUIDED
 Sections: tech_stack, data_model, api_patterns
 Cache: true
 ```
 - Load only relevant architecture sections
 - Skip detailed implementation that's not needed
 #### D. Story File (IF EXISTS)
 ```
 Pattern: {sprint_artifacts}/story-{story_id}.md
 Strategy: FULL_LOAD (if exists)
 Cache: true
 ```
 - If story exists, load for validation/continuation
 - Will be created in step 2 if not exists
 ### 5. Create Initial State File
 Create state file at `{stateFile}`:
 ```yaml
 ---
 story_id: "{story_id}"
 epic_num: {epic_num}
 story_num: {story_num}
 mode: "{mode}"
 stepsCompleted: []
 lastStep: 0
 currentStep: 1
 status: "initializing"
 started_at: "{timestamp}"
 updated_at: "{timestamp}"
 cached_context:
  project_context_loaded: true
  epic_loaded: true
  architecture_sections: ["tech_stack", "data_model", "api_patterns"]
  story_file_exists: {story_file_exists}
  story_file_path: "{story_file_path}"
 steps:
  step-01-init: { status: in_progress }
  step-02-create-story: { status: pending }
  step-03-validate-story: { status: pending }
  step-04-atdd: { status: pending }
  step-05-implement: { status: pending }
  step-06-code-review: { status: pending }
  step-07-complete: { status: pending }
  step-08-summary: { status: pending }
 ---
 ```
 ### 6. Present Initialization Summary
 Report to user:
 ```
 Pipeline Initialized for Story {story_id}
 Mode: {mode}
 Epic: {epic_num}
 Story: {story_num}
 Documents Cached:
 - Project Context: [loaded from path]
 - Epic {epic_num}: [loaded sections]
 - Architecture: [loaded sections]
 - Story File: [exists/will be created]
 Pipeline State: {stateFile}
 Ready to proceed to story creation.
 ```
 ### 7. Update State and Proceed
 Update state file:
 - Set `stepsCompleted: [1]`
 - Set `lastStep: 1`
 - Set `steps.step-01-init.status: completed`
 - Set `status: "in_progress"`
 ### 8. Present Menu (Interactive Mode Only)
 **If mode == "interactive":**
 Display menu and wait for user input:
 ```
 [C] Continue to Story Creation
 [H] Halt pipeline
 ```
 **Menu Handling:**
 - **C (Continue)**: Load and execute `{nextStepFile}`
 - **H (Halt)**: Save checkpoint, exit gracefully
 **If mode == "batch":**
 - Auto-proceed to next step
 - Load and execute `{nextStepFile}` immediately
 ## QUALITY GATE
 Before proceeding, verify:
 - [ ] All parameters resolved (story_id, epic_num, story_num, mode)
 - [ ] State file created and valid
 - [ ] Project context loaded
 - [ ] Epic definition loaded
 - [ ] Architecture sections loaded (at least tech_stack)
 ## CRITICAL STEP COMPLETION
 **ONLY WHEN** [initialization complete AND state file updated AND quality gate passed],
 load and execute `{nextStepFile}` to begin story creation.
 ---
 ## SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS
 - All parameters resolved
 - Resume state detected and handed off correctly
 - Documents cached efficiently (not reloaded)
 - State file created with proper structure
 - Menu presented and user input handled
 ### ❌ FAILURE
 - Proceeding without resolved parameters
 - Not checking for resume state first
 - Loading documents redundantly across steps
 - Not creating state file before proceeding
 - Skipping directly to implementation
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-01b-resume.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-01b-resume.md
@ -0,0 +1,213 @@
 ---
 name: 'step-01b-resume'
 description: 'Resume pipeline from checkpoint after failure or interruption'
 # Path Definitions
 workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline'
 # File References
 thisStepFile: '{workflow_path}/steps/step-01b-resume.md'
 stepsPath: '{workflow_path}/steps'
 # State Management
 stateFile: '{sprint_artifacts}/pipeline-state-{story_id}.yaml'
 ---
 # Step 1b: Resume from Checkpoint
 ## STEP GOAL
 Resume a previously started pipeline from the last completed checkpoint:
 1. Load existing pipeline state
 2. Restore cached document context
 3. Determine next step to execute
 4. Present resume options to user
 ## MANDATORY EXECUTION RULES
 ### Universal Rules
 - **NEVER** restart from step 1 if progress exists
 - **ALWAYS** restore cached context before resuming
 - **PRESERVE** all completed step data
 - **VALIDATE** state file integrity before resuming
 ### Resume Priority
 - Resume from `lastStep + 1` by default
 - Allow user to override and restart from earlier step
 - Warn if restarting would lose completed work
 ## EXECUTION SEQUENCE
 ### 1. Load Pipeline State
 Read state file: `{stateFile}`
 Extract:
 - `story_id`, `epic_num`, `story_num`, `mode`
 - `stepsCompleted`: Array of completed step numbers
 - `lastStep`: Last successfully completed step
 - `cached_context`: Document loading status
 - `steps`: Individual step status records
 ### 2. Validate State Integrity
 Check state file is valid:
 - [ ] `story_id` matches requested story
 - [ ] `stepsCompleted` is valid array
 - [ ] `lastStep` corresponds to actual completed work
 - [ ] No corruption in step records
 **If invalid:**
 - Warn user: "State file appears corrupted"
 - Offer: "Start fresh or attempt recovery?"
 ### 3. Restore Cached Context
 Re-load documents if not in memory:
 ```yaml
 cached_context:
  project_context_loaded: {reload if false}
  epic_loaded: {reload if false}
  architecture_sections: {reload specified sections}
  story_file_exists: {verify still exists}
  story_file_path: {verify path valid}
 ```
 **Efficiency note:** Only reload what's needed, don't duplicate work.
 ### 4. Present Resume Summary
 Display current state:
 ```
 Pipeline Resume for Story {story_id}
 Previous Session:
 - Started: {started_at}
 - Last Update: {updated_at}
 - Mode: {mode}
 Progress:
 - Steps Completed: {stepsCompleted}
 - Last Step: {lastStep} ({step_name})
 - Next Step: {lastStep + 1} ({next_step_name})
 Step Status:
  [✓] Step 1: Initialize
  [✓] Step 2: Create Story
  [✓] Step 3: Validate Story
  [ ] Step 4: ATDD (NEXT)
  [ ] Step 5: Implement
  [ ] Step 6: Code Review
  [ ] Step 7: Complete
  [ ] Step 8: Summary
 ```
 ### 5. Present Resume Options
 **Menu:**
 ```
 Resume Options:
 [C] Continue from Step {lastStep + 1} ({next_step_name})
 [R] Restart from specific step (will mark later steps as pending)
 [F] Fresh start (lose all progress)
 [H] Halt
 Select option:
 ```
 ### 6. Handle User Selection
 **C (Continue):**
 - Update state: `currentStep: {lastStep + 1}`
 - Load and execute next step file
 **R (Restart from step):**
 - Ask: "Which step? (2-8)"
 - Validate step number
 - Mark selected step and all later as `pending`
 - Update `lastStep` to step before selected
 - Load and execute selected step
 **F (Fresh start):**
 - Confirm: "This will lose all progress. Are you sure? (y/n)"
 - If confirmed: Delete state file, redirect to step-01-init.md
 - If not: Return to menu
 **H (Halt):**
 - Save current state
 - Exit gracefully
 ### 7. Determine Next Step File
 Map step number to file:
 | Step | File |
 |------|------|
 | 2 | step-02-create-story.md |
 | 3 | step-03-validate-story.md |
 | 4 | step-04-atdd.md |
 | 5 | step-05-implement.md |
 | 6 | step-06-code-review.md |
 | 7 | step-07-complete.md |
 | 8 | step-08-summary.md |
 ### 8. Update State and Execute
 Before loading next step:
 - Update `updated_at` to current timestamp
 - Set `currentStep` to target step
 - Set target step status to `in_progress`
 Then load and execute: `{stepsPath}/step-{XX}-{name}.md`
 ## BATCH MODE HANDLING
 If `mode == "batch"`:
 - Skip menu presentation
 - Auto-continue from `lastStep + 1`
 - If `lastStep` was a failure, check error details
 - If retryable error, attempt same step again
 - If non-retryable, halt with error report
 ## ERROR RECOVERY
 ### Common Resume Scenarios
 **Story file missing after step 2:**
 - Warn user
 - Offer to restart from step 2
 **Tests missing after step 4:**
 - Warn user
 - Offer to restart from step 4
 **Implementation incomplete after step 5:**
 - Check git status for partial changes
 - Offer to continue or rollback
 **Code review incomplete after step 6:**
 - Check if issues were logged
 - Offer to continue review or re-run
 ---
 ## SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS
 - State file loaded and validated
 - Context restored efficiently
 - User presented clear resume options
 - Correct step file loaded and executed
 - No data loss during resume
 ### ❌ FAILURE
 - Starting from step 1 when progress exists
 - Not validating state file integrity
 - Loading wrong step after resume
 - Losing completed work without confirmation
 - Not restoring cached context
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-02-create-story.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-02-create-story.md
@ -0,0 +1,244 @@
 ---
 name: 'step-02-create-story'
 description: 'Create detailed story file from epic definition with research'
 # Path Definitions
 workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline'
 # File References
 thisStepFile: '{workflow_path}/steps/step-02-create-story.md'
 nextStepFile: '{workflow_path}/steps/step-03-validate-story.md'
 checklist: '{workflow_path}/checklists/story-creation.md'
 # Role Switch
 role: sm
 agentFile: '{project-root}/_bmad/bmm/agents/sm.md'
 ---
 # Step 2: Create Story
 ## ROLE SWITCH
 **Switching to SM (Scrum Master) perspective.**
 You are now the Scrum Master facilitating story creation. Your expertise:
 - User story structure and acceptance criteria
 - BDD scenario writing (Given/When/Then)
 - Task breakdown and estimation
 - Ensuring testability of requirements
 ## STEP GOAL
 Create a detailed, implementation-ready story file:
 1. Research best practices for the domain
 2. Extract story definition from epic
 3. Write clear acceptance criteria with BDD scenarios
 4. Define tasks and subtasks
 5. Ensure all criteria are testable
 ## MANDATORY EXECUTION RULES
 ### Role-Specific Rules
 - **THINK** like a product/process expert, not a developer
 - **FOCUS** on WHAT, not HOW (implementation comes later)
 - **ENSURE** every AC is testable and measurable
 - **AVOID** technical implementation details in AC
 ### Step-Specific Rules
 - **SKIP** this step if story file already exists (check cached context)
 - **RESEARCH** best practices before writing
 - **USE** project-context.md patterns for consistency
 - **CREATE** file at `{sprint_artifacts}/story-{story_id}.md`
 ## EXECUTION SEQUENCE
 ### 1. Check if Story Already Exists
 From cached context, check `story_file_exists`:
 **If story file exists:**
 - Read and display existing story summary
 - Ask: "Story file exists. [V]alidate existing, [R]ecreate from scratch?"
 - If V: Proceed to step-03-validate-story.md
 - If R: Continue with story creation (will overwrite)
 **If story does not exist:**
 - Continue with creation
 ### 2. Research Phase (MCP Tools)
 Use MCP tools for domain research:
 ```
 mcp__exa__web_search_exa:
  query: "user story acceptance criteria best practices agile {domain}"
 mcp__exa__get_code_context_exa:
  query: "{technology} implementation patterns"
 ```
 **Extract from research:**
 - AC writing best practices
 - Common patterns for this domain
 - Anti-patterns to avoid
 ### 3. Load Epic Definition
 From cached epic file, extract for story {story_id}:
 - Story title and description
 - User persona
 - Business value
 - Initial AC ideas
 - BDD scenarios if present
 ### 4. Generate Story Content
 Create story file following template:
 ```markdown
 ---
 id: story-{story_id}
 epic: {epic_num}
 title: "{story_title}"
 status: draft
 created_at: {timestamp}
 ---
 # Story {story_id}: {story_title}
 ## User Story
 As a [persona],
 I want to [action],
 So that [benefit].
 ## Acceptance Criteria
 ### AC1: [Criterion Name]
 **Given** [precondition]
 **When** [action]
 **Then** [expected result]
 **Test Scenarios:**
 - [ ] Scenario 1: [description]
 - [ ] Scenario 2: [description]
 ### AC2: [Criterion Name]
 ...
 ## Tasks
 ### Task 1: [Task Name]
 - [ ] Subtask 1.1
 - [ ] Subtask 1.2
 ### Task 2: [Task Name]
 ...
 ## Technical Notes
 ### Database Changes
 - [any schema changes needed]
 ### API Changes
 - [any endpoint changes]
 ### UI Changes
 - [any frontend changes]
 ## Dependencies
 - [list any dependencies on other stories or systems]
 ## Out of Scope
 - [explicitly list what is NOT included]
 ```
 ### 5. Verify Story Quality
 Before saving, verify:
 - [ ] All AC have Given/When/Then format
 - [ ] Each AC has at least 2 test scenarios
 - [ ] Tasks cover all AC implementation
 - [ ] No implementation details in AC (WHAT not HOW)
 - [ ] Out of scope is defined
 - [ ] Dependencies listed if any
 ### 6. Save Story File
 Write to: `{sprint_artifacts}/story-{story_id}.md`
 Update state file:
 - `cached_context.story_file_exists: true`
 - `cached_context.story_file_path: {path}`
 ### 7. Update Pipeline State
 Update state file:
 - Add `2` to `stepsCompleted`
 - Set `lastStep: 2`
 - Set `steps.step-02-create-story.status: completed`
 - Set `steps.step-02-create-story.duration: {duration}`
 ### 8. Present Summary and Menu
 Display:
 ```
 Story {story_id} Created
 Title: {story_title}
 Acceptance Criteria: {count}
 Test Scenarios: {count}
 Tasks: {count}
 File: {story_file_path}
 ```
 **Interactive Mode Menu:**
 ```
 [C] Continue to Validation
 [E] Edit story manually
 [R] Regenerate story
 [H] Halt pipeline
 ```
 **Batch Mode:** Auto-continue to next step.
 ## QUALITY GATE
 Before proceeding:
 - [ ] Story file created at correct location
 - [ ] All AC in Given/When/Then format
 - [ ] Test scenarios defined for each AC
 - [ ] Tasks cover full implementation scope
 - [ ] File passes frontmatter validation
 ## MCP TOOLS AVAILABLE
 - `mcp__exa__web_search_exa` - Research best practices
 - `mcp__exa__get_code_context_exa` - Tech pattern research
 ## CRITICAL STEP COMPLETION
 **ONLY WHEN** [story file created AND quality gate passed AND state updated],
 load and execute `{nextStepFile}` for adversarial validation.
 ---
 ## SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS
 - Story file created with proper structure
 - All AC have BDD format
 - Test scenarios cover all AC
 - Research insights incorporated
 - State file updated correctly
 ### ❌ FAILURE
 - Story file not created or in wrong location
 - AC without Given/When/Then format
 - Missing test scenarios
 - Including implementation details in AC
 - Not updating state before proceeding
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-03-validate-story.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-03-validate-story.md
@ -0,0 +1,229 @@
 ---
 name: 'step-03-validate-story'
 description: 'Adversarial validation of story completeness and quality'
 # Path Definitions
 workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline'
 # File References
 thisStepFile: '{workflow_path}/steps/step-03-validate-story.md'
 nextStepFile: '{workflow_path}/steps/step-04-atdd.md'
 checklist: '{workflow_path}/checklists/story-validation.md'
 # Role (same as step 2, no switch needed)
 role: sm
 ---
 # Step 3: Validate Story
 ## ROLE CONTINUATION
 **Continuing as SM (Scrum Master) - Adversarial Validator mode.**
 You are now an ADVERSARIAL validator. Your job is to FIND PROBLEMS, not approve.
 Challenge every assumption. Question every AC. Ensure the story is truly ready.
 ## STEP GOAL
 Perform rigorous validation of the story file:
 1. Research common AC anti-patterns
 2. Validate each acceptance criterion
 3. Check technical feasibility
 4. Ensure all edge cases covered
 5. Fix all issues found
 6. Add validation report
 ## MANDATORY EXECUTION RULES
 ### Adversarial Mindset
 - **ASSUME** something is wrong - find it
 - **NEVER** say "looks good" without deep analysis
 - **QUESTION** every assumption
 - **FIND** at least 3 issues (if no issues, you haven't looked hard enough)
 ### Validation Rules
 - Every AC must be: Specific, Measurable, Testable
 - Every AC must have test scenarios
 - No vague terms: "should", "might", "could", "etc."
 - No undefined boundaries: "appropriate", "reasonable"
 ## EXECUTION SEQUENCE
 ### 1. Research Validation Patterns
 Use MCP for research:
 ```
 mcp__exa__web_search_exa:
  query: "acceptance criteria anti-patterns common mistakes user stories"
 ```
 **Extract:**
 - Common AC problems
 - Validation techniques
 - Red flags to look for
 ### 2. Load Story File
 Read from cached path: `{story_file_path}`
 Parse and extract:
 - All acceptance criteria
 - All test scenarios
 - Task definitions
 - Dependencies
 ### 3. Validate Each AC (MANDATORY CHECKLIST)
 For EACH acceptance criterion:
 **Structure Check:**
 - [ ] Has Given/When/Then format
 - [ ] Given is a valid precondition
 - [ ] When is a clear action
 - [ ] Then is a measurable outcome
 **Quality Check:**
 - [ ] Specific (no vague terms)
 - [ ] Measurable (clear success criteria)
 - [ ] Testable (can write automated test)
 - [ ] Independent (no hidden dependencies)
 **Completeness Check:**
 - [ ] Edge cases considered
 - [ ] Error scenarios defined
 - [ ] Boundary conditions clear
 **Anti-pattern Check:**
 - [ ] No implementation details
 - [ ] No AND conjunctions (split into multiple AC)
 - [ ] No OR alternatives (ambiguous)
 ### 4. Technical Feasibility Check
 Cross-reference with architecture.md (from cache):
 - [ ] Required data model exists or migration defined
 - [ ] API endpoints fit existing patterns
 - [ ] No conflicts with existing functionality
 - [ ] Security model (RLS) can support requirements
 ### 5. Test Scenario Coverage
 Verify test scenarios:
 - [ ] At least 2 scenarios per AC
 - [ ] Happy path covered
 - [ ] Error paths covered
 - [ ] Edge cases covered
 - [ ] Each scenario is unique (no duplicates)
 ### 6. Document All Issues Found
 Create issues list:
 ```yaml
 issues_found:
  - id: 1
    severity: high|medium|low
    ac: AC1
    problem: "Description of issue"
    fix: "How to fix it"
  - id: 2
    ...
 ```
 ### 7. Fix All Issues
 For EACH issue:
 1. Edit the story file to fix
 2. Document the fix
 3. Verify fix is correct
 ### 8. Add Validation Report
 Append to story file:
 ```yaml
 # Validation Report
 validated_by: sm-validator
 validated_at: {timestamp}
 issues_found: {count}
 issues_fixed: {count}
 quality_score: {0-100}
 test_scenarios_count: {count}
 edge_cases_covered: {list}
 ready_for_dev: true|false
 validation_notes: |
  - {note 1}
  - {note 2}
 ```
 ### 9. Update Pipeline State
 Update state file:
 - Add `3` to `stepsCompleted`
 - Set `lastStep: 3`
 - Set `steps.step-03-validate-story.status: completed`
 - Record `issues_found` and `issues_fixed` counts
 ### 10. Present Summary and Menu
 Display:
 ```
 Story Validation Complete
 Issues Found: {count}
 Issues Fixed: {count}
 Quality Score: {score}/100
 Validation Areas:
 - AC Structure: ✓/✗
 - Testability: ✓/✗
 - Technical Feasibility: ✓/✗
 - Edge Cases: ✓/✗
 Ready for Development: {yes/no}
 ```
 **Interactive Mode Menu:**
 ```
 [C] Continue to ATDD (Test Generation)
 [R] Re-validate
 [E] Edit story manually
 [H] Halt pipeline
 ```
 **Batch Mode:** Auto-continue if ready_for_dev: true
 ## QUALITY GATE
 Before proceeding:
 - [ ] All issues identified and fixed
 - [ ] Quality score >= 80
 - [ ] ready_for_dev: true
 - [ ] Validation report appended to story file
 ## CRITICAL STEP COMPLETION
 **ONLY WHEN** [validation complete AND quality gate passed AND ready_for_dev: true],
 load and execute `{nextStepFile}` for ATDD test generation.
 ---
 ## SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS
 - Found and fixed at least 3 issues
 - Quality score >= 80
 - All AC pass validation checklist
 - Validation report added
 - Story marked ready for dev
 ### ❌ FAILURE
 - Approving story as "looks good" without deep review
 - Missing edge case analysis
 - Not fixing all identified issues
 - Proceeding with quality_score < 80
 - Not adding validation report
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-04-atdd.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-04-atdd.md
@ -0,0 +1,308 @@
 ---
 name: 'step-04-atdd'
 description: 'Generate failing acceptance tests before implementation (RED phase)'
 # Path Definitions
 workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline'
 # File References
 thisStepFile: '{workflow_path}/steps/step-04-atdd.md'
 nextStepFile: '{workflow_path}/steps/step-05-implement.md'
 checklist: '{workflow_path}/checklists/atdd.md'
 # Role Switch
 role: tea
 agentFile: '{project-root}/_bmad/bmm/agents/tea.md'
 ---
 # Step 4: ATDD - Acceptance Test-Driven Development
 ## ROLE SWITCH
 **Switching to TEA (Test Engineering Architect) perspective.**
 You are now the Test Engineering Architect. Your expertise:
 - Test strategy and design
 - Playwright and Vitest patterns
 - Data factories and fixtures
 - Test-first development methodology
 ## STEP GOAL
 Generate FAILING acceptance tests BEFORE implementation (RED phase):
 1. Research test patterns for the technology stack
 2. Analyze each acceptance criterion
 3. Determine appropriate test level (E2E, API, Component, Unit)
 4. Write tests in Given/When/Then format
 5. Create data factories and fixtures
 6. Verify tests FAIL (they should - nothing is implemented yet)
 7. Generate implementation checklist for DEV
 ## MANDATORY EXECUTION RULES
 ### ATDD Principles
 - **TESTS FIRST** - Write tests before any implementation
 - **TESTS MUST FAIL** - If tests pass, something is wrong
 - **ONE AC = ONE TEST** (minimum) - More for complex scenarios
 - **REALISTIC DATA** - Use factories, not hardcoded values
 ### Test Architecture Rules
 - Use `data-testid` selectors for stability
 - Network-first pattern (route interception before navigation)
 - Auto-cleanup fixtures
 - No flaky timing-based assertions
 ## EXECUTION SEQUENCE
 ### 1. Research Test Patterns
 Use MCP tools:
 ```
 mcp__exa__web_search_exa:
  query: "playwright acceptance test best practices Next.js TypeScript 2025"
 mcp__exa__get_code_context_exa:
  query: "vitest playwright test fixtures factories faker patterns"
 ```
 **Extract:**
 - Current best practices for Next.js testing
 - Fixture and factory patterns
 - Common pitfalls to avoid
 ### 2. Analyze Acceptance Criteria
 From cached story file, for EACH acceptance criterion:
 ```yaml
 ac_analysis:
  - ac_id: AC1
    title: "{ac_title}"
    given: "{given clause}"
    when: "{when clause}"
    then: "{then clause}"
    test_level: E2E|API|Component|Unit
    test_file: "{proposed test file path}"
    requires_fixtures: [list]
    requires_factories: [list]
    data_testids_needed: [list]
 ```
 ### 3. Determine Test Levels
 For each AC, determine appropriate level:
 | Level | When to Use |
 |-------|-------------|
 | E2E | Full user flows, UI interactions |
 | API | Server actions, API endpoints |
 | Component | React component behavior |
 | Unit | Pure business logic, utilities |
 ### 4. Create Data Factories
 For each entity needed in tests:
 ```typescript
 // src/tests/factories/{entity}.factory.ts
 import { faker } from "@faker-js/faker";
 export function create{Entity}(overrides: Partial<{Entity}> = {}): {Entity} {
  return {
    id: faker.string.uuid(),
    // ... realistic fake data
    ...overrides,
  };
 }
 ```
 ### 5. Create Test Fixtures
 For each test setup pattern:
 ```typescript
 // src/tests/fixtures/{feature}.fixture.ts
 import { test as base } from "vitest";
 // or for E2E:
 import { test as base } from "@playwright/test";
 export const test = base.extend<{
  // fixture types
 }>({
  // fixture implementations with auto-cleanup
 });
 ```
 ### 6. Write Acceptance Tests
 For EACH acceptance criterion:
 ```typescript
 // src/tests/{appropriate-dir}/{feature}.test.ts
 describe("AC{N}: {ac_title}", () => {
  test("Given {given}, When {when}, Then {then}", async () => {
    // Arrange (Given)
    const data = createTestData();
    // Act (When)
    const result = await performAction(data);
    // Assert (Then)
    expect(result).toMatchExpectedOutcome();
  });
  // Additional scenarios from story
  test("Edge case: {scenario}", async () => {
    // ...
  });
 });
 ```
 ### 7. Document Required data-testids
 Create list of data-testids that DEV must implement:
 ```markdown
 ## Required data-testid Attributes
 | Element | data-testid | Purpose |
 |---------|-------------|---------|
 | Submit button | submit-{feature} | Test form submission |
 | Error message | error-{feature} | Verify error display |
 | ... | ... | ... |
 ```
 ### 8. Verify Tests FAIL
 Run tests and verify they fail:
 ```bash
 npm test -- --run {test-file}
 ```
 **Expected:** All tests should FAIL (RED phase)
 - "Cannot find element with data-testid"
 - "Function not implemented"
 - "Route not found"
 **If tests PASS:** Something is wrong - investigate
 ### 9. Create ATDD Checklist
 Create: `{sprint_artifacts}/atdd-checklist-{story_id}.md`
 ```markdown
 # ATDD Checklist for Story {story_id}
 ## Test Files Created
 - [ ] {test_file_1}
 - [ ] {test_file_2}
 ## Factories Created
 - [ ] {factory_1}
 - [ ] {factory_2}
 ## Fixtures Created
 - [ ] {fixture_1}
 ## Implementation Requirements for DEV
 ### Required data-testid Attributes
 | Element | Attribute |
 |---------|-----------|
 | ... | ... |
 ### API Endpoints Needed
 - [ ] {endpoint_1}
 - [ ] {endpoint_2}
 ### Database Changes
 - [ ] {migration_1}
 ## Test Status (RED Phase)
 All tests should FAIL until implementation:
 - [ ] {test_1}: FAILING ✓
 - [ ] {test_2}: FAILING ✓
 ```
 ### 10. Update Pipeline State
 Update state file:
 - Add `4` to `stepsCompleted`
 - Set `lastStep: 4`
 - Set `steps.step-04-atdd.status: completed`
 - Record test file paths created
 ### 11. Present Summary and Menu
 Display:
 ```
 ATDD Complete - RED Phase Verified
 Tests Created: {count}
 All Tests FAILING: ✓ (as expected)
 Test Files:
 - {test_file_1}
 - {test_file_2}
 Factories: {count}
 Fixtures: {count}
 data-testids Required: {count}
 ATDD Checklist: {checklist_path}
 Next: DEV will implement to make tests GREEN
 ```
 **Interactive Mode Menu:**
 ```
 [C] Continue to Implementation
 [T] Run tests again
 [E] Edit tests
 [H] Halt pipeline
 ```
 **Batch Mode:** Auto-continue
 ## QUALITY GATE
 Before proceeding:
 - [ ] Test file created for each AC
 - [ ] All tests FAIL (RED phase verified)
 - [ ] Factories created for test data
 - [ ] data-testid requirements documented
 - [ ] ATDD checklist created
 ## MCP TOOLS AVAILABLE
 - `mcp__exa__web_search_exa` - Test pattern research
 - `mcp__exa__get_code_context_exa` - Framework-specific patterns
 ## CRITICAL STEP COMPLETION
 **ONLY WHEN** [tests created AND all tests FAIL AND checklist created],
 load and execute `{nextStepFile}` for implementation.
 ---
 ## SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS
 - Tests written for all AC
 - All tests FAIL (red phase)
 - Factories use faker, not hardcoded data
 - Fixtures have auto-cleanup
 - data-testid requirements documented
 - ATDD checklist complete
 ### ❌ FAILURE
 - Tests PASS before implementation
 - Hardcoded test data
 - Missing edge case tests
 - No data-testid documentation
 - Skipping to implementation without tests
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-05-implement.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-05-implement.md
@ -0,0 +1,285 @@
 ---
 name: 'step-05-implement'
 description: 'Implement story to make tests pass (GREEN phase)'
 # Path Definitions
 workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline'
 # File References
 thisStepFile: '{workflow_path}/steps/step-05-implement.md'
 nextStepFile: '{workflow_path}/steps/step-06-code-review.md'
 checklist: '{workflow_path}/checklists/implementation.md'
 # Role Switch
 role: dev
 agentFile: '{project-root}/_bmad/bmm/agents/dev.md'
 ---
 # Step 5: Implement Story
 ## ROLE SWITCH
 **Switching to DEV (Developer) perspective.**
 You are now the Developer implementing the story. Your expertise:
 - Next.js 16 with App Router
 - TypeScript strict mode
 - Supabase with RLS
 - TDD methodology (make tests GREEN)
 ## STEP GOAL
 Implement the story using TDD methodology:
 1. Research implementation patterns
 2. Review ATDD checklist and failing tests
 3. For each failing test: implement minimal code to pass
 4. Run tests, verify GREEN
 5. Ensure lint and build pass
 6. No refactoring yet (that's code review)
 ## MANDATORY EXECUTION RULES
 ### TDD Rules (RED-GREEN-REFACTOR)
 - **GREEN PHASE** - Make tests pass with minimal code
 - **ONE TEST AT A TIME** - Don't implement all at once
 - **MINIMAL CODE** - Just enough to pass, no over-engineering
 - **RUN TESTS FREQUENTLY** - After each change
 ### Implementation Rules
 - **Follow project-context.md** patterns exactly
 - **Result type** for all server actions (never throw)
 - **snake_case** for database columns
 - **Multi-tenancy** with tenant_id on all tables
 - **RLS policies** for all new tables
 ## EXECUTION SEQUENCE
 ### 1. Research Implementation Patterns
 Use MCP tools:
 ```
 mcp__exa__get_code_context_exa:
  query: "Next.js 16 server actions Supabase RLS multi-tenant"
 mcp__supabase__list_tables:
  # Understand current schema
 ```
 ### 2. Review ATDD Checklist
 Load: `{sprint_artifacts}/atdd-checklist-{story_id}.md`
 Extract:
 - Required data-testid attributes
 - API endpoints needed
 - Database changes required
 - Current failing tests
 ### 3. Run Failing Tests
 ```bash
 npm test -- --run
 ```
 Confirm all tests are FAILING (from ATDD phase).
 ### 4. Implementation Loop
 For EACH acceptance criterion:
 **A. Focus on one failing test:**
 ```bash
 npm test -- --run --grep "{test_name}"
 ```
 **B. Implement minimal code:**
 - Database migration if needed
 - Server action / API route
 - UI component with data-testid
 - Type definitions
 **C. Run targeted test:**
 ```bash
 npm test -- --run --grep "{test_name}"
 ```
 **D. Verify GREEN:**
 - Test passes ✓
 - Move to next test
 ### 5. Database Migrations
 For any schema changes:
 ```bash
 # Create migration file
 npx supabase migration new {name}
 # Migration content
 -- Enable RLS
 alter table {table} enable row level security;
 -- RLS policies
 create policy "Tenants can view own data"
  on {table} for select
  using (tenant_id = auth.jwt() ->> 'tenant_id');
 ```
 Apply to remote:
 ```bash
 npx supabase db push
 ```
 ### 6. Server Actions Pattern
 Follow project-context.md pattern:
 ```typescript
 // src/modules/{module}/actions/{action}.ts
 "use server";
 import { ok, err, Result } from "@/lib/result";
 import { createClient } from "@/lib/supabase/server";
 export async function actionName(
  input: InputType
 ): Promise<Result<OutputType>> {
  const supabase = await createClient();
  const { data, error } = await supabase
    .from("table")
    .select("*")
    .eq("tenant_id", tenantId);
  if (error) {
    return err("DB_ERROR", error.message);
  }
  return ok(data);
 }
 ```
 ### 7. UI Components Pattern
 ```tsx
 // src/modules/{module}/components/{Component}.tsx
 "use client";
 export function Component({ data }: Props) {
  return (
    <div data-testid="{feature}-container">
      <button data-testid="{feature}-submit">
        Submit
      </button>
    </div>
  );
 }
 ```
 ### 8. Run Full Test Suite
 After all AC implemented:
 ```bash
 npm test -- --run
 ```
 **All tests should pass (GREEN).**
 ### 9. Lint and Build
 ```bash
 npm run lint
 npm run build
 ```
 Fix any issues that arise.
 ### 10. Verify Implementation Completeness
 Check against ATDD checklist:
 - [ ] All data-testid attributes added
 - [ ] All API endpoints created
 - [ ] All database migrations applied
 - [ ] All tests passing
 ### 11. Update Pipeline State
 Update state file:
 - Add `5` to `stepsCompleted`
 - Set `lastStep: 5`
 - Set `steps.step-05-implement.status: completed`
 - Record files modified
 ### 12. Present Summary and Menu
 Display:
 ```
 Implementation Complete - GREEN Phase
 Tests: {passed}/{total} PASSING
 Lint: ✓ Clean
 Build: ✓ Success
 Files Modified:
 - {file_1}
 - {file_2}
 Migrations Applied:
 - {migration_1}
 Ready for Code Review
 ```
 **Interactive Mode Menu:**
 ```
 [C] Continue to Code Review
 [T] Run tests again
 [B] Run build again
 [H] Halt pipeline
 ```
 **Batch Mode:** Auto-continue if all tests pass
 ## QUALITY GATE
 Before proceeding:
 - [ ] All tests pass (GREEN)
 - [ ] Lint clean
 - [ ] Build succeeds
 - [ ] All ATDD checklist items complete
 - [ ] RLS policies for new tables
 ## MCP TOOLS AVAILABLE
 - `mcp__exa__get_code_context_exa` - Implementation patterns
 - `mcp__supabase__list_tables` - Schema inspection
 - `mcp__supabase__execute_sql` - Query testing
 - `mcp__supabase__apply_migration` - Schema changes
 - `mcp__supabase__generate_typescript_types` - Type sync
 ## CRITICAL STEP COMPLETION
 **ONLY WHEN** [all tests pass AND lint clean AND build succeeds],
 load and execute `{nextStepFile}` for code review.
 ---
 ## SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS
 - All tests pass (GREEN phase)
 - TDD methodology followed
 - Result type used (no throws)
 - RLS policies in place
 - Lint and build clean
 ### ❌ FAILURE
 - Tests still failing
 - Skipping tests to implement faster
 - Throwing errors instead of Result type
 - Missing RLS policies
 - Build or lint failures
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-06-code-review.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-06-code-review.md
@ -0,0 +1,294 @@
 ---
 name: 'step-06-code-review'
 description: 'Adversarial code review finding 3-10 specific issues'
 # Path Definitions
 workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline'
 # File References
 thisStepFile: '{workflow_path}/steps/step-06-code-review.md'
 nextStepFile: '{workflow_path}/steps/step-07-complete.md'
 checklist: '{workflow_path}/checklists/code-review.md'
 # Role (continue as dev, but reviewer mindset)
 role: dev
 requires_fresh_context: true  # In batch mode, checkpoint here for unbiased review
 ---
 # Step 6: Code Review
 ## ROLE CONTINUATION - ADVERSARIAL MODE
 **Continuing as DEV but switching to ADVERSARIAL REVIEWER mindset.**
 You are now a critical code reviewer. Your job is to FIND PROBLEMS.
 - **NEVER** say "looks good" - that's a failure
 - **MUST** find 3-10 specific issues
 - **FIX** every issue you find
 ## STEP GOAL
 Perform adversarial code review:
 1. Query Supabase advisors for security/performance issues
 2. Identify all files changed for this story
 3. Review each file against checklist
 4. Find and document 3-10 issues (MANDATORY)
 5. Fix all issues
 6. Verify tests still pass
 ## MANDATORY EXECUTION RULES
 ### Adversarial Requirements
 - **MINIMUM 3 ISSUES** - If you found fewer, look harder
 - **MAXIMUM 10 ISSUES** - Prioritize if more found
 - **NO "LOOKS GOOD"** - This is FORBIDDEN
 - **FIX EVERYTHING** - Don't just report, fix
 ### Review Categories (find issues in EACH)
 1. Security
 2. Performance
 3. Error Handling
 4. Test Coverage
 5. Code Quality
 6. Architecture
 ## EXECUTION SEQUENCE
 ### 1. Query Supabase Advisors
 Use MCP tools:
 ```
 mcp__supabase__get_advisors:
  type: "security"
 mcp__supabase__get_advisors:
  type: "performance"
 ```
 Document any issues found.
 ### 2. Identify Changed Files
 ```bash
 git status
 git diff --name-only HEAD~1
 ```
 List all files changed for story {story_id}.
 ### 3. Review Each Category
 #### SECURITY REVIEW
 For each file, check:
 - [ ] No SQL injection vulnerabilities
 - [ ] No XSS vulnerabilities
 - [ ] Auth checks on all protected routes
 - [ ] RLS policies exist and are correct
 - [ ] No credential exposure (API keys, secrets)
 - [ ] Input validation present
 - [ ] Rate limiting considered
 #### PERFORMANCE REVIEW
 - [ ] No N+1 query patterns
 - [ ] Indexes exist for query patterns
 - [ ] No unnecessary re-renders
 - [ ] Proper caching strategy
 - [ ] Efficient data fetching
 - [ ] Bundle size impact considered
 #### ERROR HANDLING REVIEW
 - [ ] Result type used consistently
 - [ ] Error messages are user-friendly
 - [ ] Edge cases handled
 - [ ] Null/undefined checked
 - [ ] Network errors handled gracefully
 #### TEST COVERAGE REVIEW
 - [ ] All AC have tests
 - [ ] Edge cases tested
 - [ ] Error paths tested
 - [ ] Mocking is appropriate (not excessive)
 - [ ] Tests are deterministic
 #### CODE QUALITY REVIEW
 - [ ] DRY - no duplicate code
 - [ ] SOLID principles followed
 - [ ] TypeScript strict mode compliant
 - [ ] No any types
 - [ ] Functions are focused (single responsibility)
 - [ ] Naming is clear and consistent
 #### ARCHITECTURE REVIEW
 - [ ] Module boundaries respected
 - [ ] Imports from index.ts only
 - [ ] Server/client separation correct
 - [ ] Data flow is clear
 - [ ] No circular dependencies
 ### 4. Document All Issues
 For each issue found:
 ```yaml
 issue_{n}:
  severity: critical|high|medium|low
  category: security|performance|error-handling|testing|quality|architecture
  file: "{file_path}"
  line: {line_number}
  problem: |
    {Clear description of the issue}
  risk: |
    {What could go wrong if not fixed}
  fix: |
    {How to fix it}
 ```
 ### 5. Fix All Issues
 For EACH issue documented:
 1. Edit the file to fix the issue
 2. Add test if issue wasn't covered
 3. Verify the fix is correct
 4. Mark as fixed
 ### 6. Run Verification
 After all fixes:
 ```bash
 npm run lint
 npm run build
 npm test -- --run
 ```
 All must pass.
 ### 7. Create Review Report
 Append to story file or create `{sprint_artifacts}/review-{story_id}.md`:
 ```markdown
 # Code Review Report - Story {story_id}
 ## Summary
 - Issues Found: {count}
 - Issues Fixed: {count}
 - Categories Reviewed: {list}
 ## Issues Detail
 ### Issue 1: {title}
 - **Severity:** {severity}
 - **Category:** {category}
 - **File:** {file}:{line}
 - **Problem:** {description}
 - **Fix Applied:** {fix_description}
 ### Issue 2: {title}
 ...
 ## Security Checklist
 - [x] RLS policies verified
 - [x] No credential exposure
 - [x] Input validation present
 ## Performance Checklist
 - [x] No N+1 queries
 - [x] Indexes verified
 ## Final Status
 All issues resolved. Tests passing.
 Reviewed by: DEV (adversarial)
 Reviewed at: {timestamp}
 ```
 ### 8. Update Pipeline State
 Update state file:
 - Add `6` to `stepsCompleted`
 - Set `lastStep: 6`
 - Set `steps.step-06-code-review.status: completed`
 - Record `issues_found` and `issues_fixed`
 ### 9. Present Summary and Menu
 Display:
 ```
 Code Review Complete
 Issues Found: {count} (minimum 3 required)
 Issues Fixed: {count}
 By Category:
 - Security: {count}
 - Performance: {count}
 - Error Handling: {count}
 - Test Coverage: {count}
 - Code Quality: {count}
 - Architecture: {count}
 All Tests: PASSING
 Lint: CLEAN
 Build: SUCCESS
 Review Report: {report_path}
 ```
 **Interactive Mode Menu:**
 ```
 [C] Continue to Completion
 [R] Run another review pass
 [T] Run tests again
 [H] Halt pipeline
 ```
 **Batch Mode:** Auto-continue if minimum issues found and fixed
 ## QUALITY GATE
 Before proceeding:
 - [ ] Minimum 3 issues found and fixed
 - [ ] All categories reviewed
 - [ ] All tests still passing
 - [ ] Lint clean
 - [ ] Build succeeds
 - [ ] Review report created
 ## MCP TOOLS AVAILABLE
 - `mcp__supabase__get_advisors` - Security/performance checks
 - `mcp__supabase__execute_sql` - Query verification
 ## CRITICAL STEP COMPLETION
 **ONLY WHEN** [minimum 3 issues found AND all fixed AND tests pass],
 load and execute `{nextStepFile}` for story completion.
 ---
 ## SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS
 - Found and fixed 3-10 issues
 - All categories reviewed
 - Tests still passing after fixes
 - Review report complete
 - No "looks good" shortcuts
 ### ❌ FAILURE
 - Saying "looks good" or "no issues found"
 - Finding fewer than 3 issues
 - Not fixing issues found
 - Tests failing after fixes
 - Skipping review categories
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-07-complete.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-07-complete.md
@ -0,0 +1,210 @@
 ---
 name: 'step-07-complete'
 description: 'Update sprint status and create git commit'
 # Path Definitions
 workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline'
 # File References
 thisStepFile: '{workflow_path}/steps/step-07-complete.md'
 nextStepFile: '{workflow_path}/steps/step-08-summary.md'
 # Role Switch
 role: sm
 agentFile: '{project-root}/_bmad/bmm/agents/sm.md'
 ---
 # Step 7: Complete Story
 ## ROLE SWITCH
 **Switching back to SM (Scrum Master) perspective.**
 You are completing the story lifecycle:
 - Update sprint tracking
 - Create git commit
 - Finalize documentation
 ## STEP GOAL
 Complete the story development lifecycle:
 1. Final verification (tests, lint, build)
 2. Update sprint-status.yaml
 3. Create git commit with proper message
 4. Update story file status
 ## MANDATORY EXECUTION RULES
 ### Completion Rules
 - **VERIFY** everything passes before committing
 - **UPDATE** all tracking files
 - **COMMIT** with conventional commit message
 - **DOCUMENT** completion metadata
 ## EXECUTION SEQUENCE
 ### 1. Final Verification
 Run full verification suite:
 ```bash
 npm test -- --run
 npm run lint
 npm run build
 ```
 All must pass before proceeding.
 **If any fail:** HALT and report issues.
 ### 2. Update Story File Status
 Edit story file, update frontmatter:
 ```yaml
 ---
 status: done
 completed_at: {timestamp}
 implementation_notes: |
  - Tests created and passing
  - Code reviewed and approved
  - {count} issues found and fixed
 ---
 ```
 ### 3. Update Sprint Status
 Edit: `{sprint_artifacts}/sprint-status.yaml`
 Find story {story_id} and update:
 ```yaml
 stories:
  - id: "{story_id}"
    status: done
    completed_at: {timestamp}
    metadata:
      tests_passing: true
      code_reviewed: true
      issues_found: {count}
      issues_fixed: {count}
      pipeline_version: "story-pipeline-v2.0"
 ```
 ### 4. Stage Git Changes
 ```bash
 git add src/
 git add docs/sprint-artifacts/story-{story_id}.md
 git add docs/sprint-artifacts/sprint-status.yaml
 git add src/supabase/migrations/
 ```
 ### 5. Create Git Commit
 Check for changes:
 ```bash
 git diff --cached --quiet
 ```
 If changes exist, create commit:
 ```bash
 git commit -m "$(cat <<'EOF'
 feat(epic-{epic_num}): complete story {story_id}
 - Acceptance tests created for all criteria
 - All tests passing (TDD green phase)
 - Code reviewed: {issues_found} issues found and fixed
 Story: {story_title}
 Pipeline: story-pipeline-v2.0
 🤖 Generated with BMAD Story Pipeline
 Co-Authored-By: Claude <noreply@anthropic.com>
 EOF
 )"
 ```
 ### 6. Verify Commit
 ```bash
 git log -1 --oneline
 git status
 ```
 Confirm:
 - Commit created successfully
 - Working directory clean (or only untracked files)
 ### 7. Update Pipeline State
 Update state file:
 - Add `7` to `stepsCompleted`
 - Set `lastStep: 7`
 - Set `steps.step-07-complete.status: completed`
 - Set `status: completing`
 ### 8. Present Summary and Menu
 Display:
 ```
 Story {story_id} Completed
 Sprint Status: Updated ✓
 Story Status: done ✓
 Git Commit: Created ✓
 Commit: {commit_hash}
 Message: feat(epic-{epic_num}): complete story {story_id}
 Files Committed:
 - {file_count} files
 Next: Generate summary and audit trail
 ```
 **Interactive Mode Menu:**
 ```
 [C] Continue to Summary
 [L] View git log
 [S] View git status
 [H] Halt (story is complete, audit pending)
 ```
 **Batch Mode:** Auto-continue to summary
 ## QUALITY GATE
 Before proceeding:
 - [ ] All tests pass
 - [ ] Lint clean
 - [ ] Build succeeds
 - [ ] Sprint status updated
 - [ ] Git commit created
 - [ ] Story status set to done
 ## CRITICAL STEP COMPLETION
 **ONLY WHEN** [verification passes AND commit created AND status updated],
 load and execute `{nextStepFile}` for summary generation.
 ---
 ## SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS
 - All verification passes
 - Sprint status updated correctly
 - Conventional commit created
 - Story marked as done
 - Clean git state
 ### ❌ FAILURE
 - Committing with failing tests
 - Missing sprint status update
 - Malformed commit message
 - Not including all changed files
 - Story not marked done
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-08-summary.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/steps/step-08-summary.md
@ -0,0 +1,273 @@
 ---
 name: 'step-08-summary'
 description: 'Generate audit trail and pipeline summary report'
 # Path Definitions
 workflow_path: '{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline'
 # File References
 thisStepFile: '{workflow_path}/steps/step-08-summary.md'
 auditFile: '{sprint_artifacts}/audit-{story_id}-{date}.yaml'
 # No role needed - orchestrator
 role: null
 ---
 # Step 8: Pipeline Summary
 ## STEP GOAL
 Generate final audit trail and summary report:
 1. Calculate pipeline metrics
 2. Generate audit trail file
 3. Create summary report
 4. Clean up pipeline state
 5. Suggest next steps
 ## EXECUTION SEQUENCE
 ### 1. Calculate Pipeline Metrics
 From pipeline state file, calculate:
 ```yaml
 metrics:
  total_duration: {sum of all step durations}
  steps_completed: {count}
  issues_found: {from code review}
  issues_fixed: {from code review}
  tests_created: {count}
  files_modified: {count}
  migrations_applied: {count}
 ```
 ### 2. Generate Audit Trail
 Create: `{auditFile}`
 ```yaml
 ---
 audit_version: "1.0"
 pipeline: "story-pipeline-v2.0"
 story_id: "{story_id}"
 epic_num: {epic_num}
 ---
 # Pipeline Audit Trail
 ## Execution Summary
 started_at: "{started_at}"
 completed_at: "{timestamp}"
 total_duration: "{duration}"
 mode: "{mode}"
 status: "completed"
 ## Steps Executed
 steps:
  - step: 1
    name: "Initialize"
    status: completed
    duration: "{duration}"
  - step: 2
    name: "Create Story"
    status: completed
    duration: "{duration}"
    agent: sm
    output: "{story_file_path}"
  - step: 3
    name: "Validate Story"
    status: completed
    duration: "{duration}"
    agent: sm
    issues_found: {count}
    issues_fixed: {count}
  - step: 4
    name: "ATDD"
    status: completed
    duration: "{duration}"
    agent: tea
    tests_created: {count}
    test_files:
      - "{file_1}"
      - "{file_2}"
  - step: 5
    name: "Implement"
    status: completed
    duration: "{duration}"
    agent: dev
    files_modified: {count}
    migrations:
      - "{migration_1}"
  - step: 6
    name: "Code Review"
    status: completed
    duration: "{duration}"
    agent: dev
    issues_found: {count}
    issues_fixed: {count}
    categories_reviewed:
      - security
      - performance
      - error-handling
      - testing
      - quality
      - architecture
  - step: 7
    name: "Complete"
    status: completed
    duration: "{duration}"
    agent: sm
    commit_hash: "{hash}"
  - step: 8
    name: "Summary"
    status: completed
    duration: "{duration}"
 ## Quality Gates
 gates:
  story_creation:
    passed: true
    criteria_met: [list]
  validation:
    passed: true
    quality_score: {score}
  atdd:
    passed: true
    tests_failing: true  # Expected in red phase
  implementation:
    passed: true
    tests_passing: true
  code_review:
    passed: true
    minimum_issues_found: true
 ## Artifacts Produced
 artifacts:
  story_file: "{path}"
  test_files:
    - "{path}"
  migrations:
    - "{path}"
  atdd_checklist: "{path}"
  review_report: "{path}"
  commit: "{hash}"
 ## Token Efficiency
 token_estimate:
  traditional_approach: "~71K tokens (6 claude calls)"
  step_file_approach: "~{actual}K tokens (1 session)"
  savings: "{percentage}%"
 ```
 ### 3. Generate Summary Report
 Display to user:
 ```
 ═══════════════════════════════════════════════════════════════════
                    PIPELINE COMPLETE: Story {story_id}
 ═══════════════════════════════════════════════════════════════════
 📊 EXECUTION SUMMARY
 ────────────────────
 Duration: {total_duration}
 Mode: {mode}
 Status: ✓ Completed Successfully
 📋 STORY DETAILS
 ────────────────────
 Epic: {epic_num}
 Title: {story_title}
 Commit: {commit_hash}
 ✅ QUALITY METRICS
 ────────────────────
 Validation Score: {score}/100
 Issues Found: {count}
 Issues Fixed: {count}
 Tests Created: {count}
 Files Modified: {count}
 📁 ARTIFACTS
 ────────────────────
 Story: {story_file}
 Tests: {test_count} files
 Migrations: {migration_count}
 Audit: {audit_file}
 💰 TOKEN EFFICIENCY
 ────────────────────
 Traditional: ~71K tokens
 Step-file: ~{actual}K tokens
 Savings: {percentage}%
 ═══════════════════════════════════════════════════════════════════
 ```
 ### 4. Update Final Pipeline State
 Update state file:
 - Add `8` to `stepsCompleted`
 - Set `lastStep: 8`
 - Set `status: completed`
 - Set `completed_at: {timestamp}`
 ### 5. Suggest Next Steps
 Display:
 ```
 📌 NEXT STEPS
 ────────────────────
 1. Review commit: git show {hash}
 2. Push when ready: git push
 3. Next story: bmad build {next_story_id}
 4. View audit: cat {audit_file}
 Optional:
 - Run verification: bmad verify {story_id}
 - Run with coverage: npm test -- --coverage
 ```
 ### 6. Clean Up (Optional)
 In batch mode, optionally archive pipeline state:
 ```bash
 mv {state_file} {state_file}.completed
 ```
 Or keep for reference.
 ## COMPLETION
 Pipeline execution complete. No next step to load.
 Display final message:
 ```
 Pipeline complete. Story {story_id} is ready.
 ```
 ---
 ## SUCCESS/FAILURE METRICS
 ### ✅ SUCCESS
 - Audit trail generated with all details
 - Summary displayed clearly
 - All metrics calculated
 - State marked complete
 - Next steps provided
 ### ❌ FAILURE
 - Missing audit trail
 - Incomplete metrics
 - State not finalized
 - No summary provided
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/templates/audit-trail.yaml
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/templates/audit-trail.yaml
@ -0,0 +1,248 @@
 # Audit Trail Template
 # Generated at pipeline completion
 # Location: {sprint_artifacts}/audit-{story_id}-{date}.yaml
 ---
 audit_version: "1.0"
 pipeline_version: "story-pipeline-v2.0"
 # Story identification
 story_id: "{{story_id}}"
 epic_num: {{epic_num}}
 story_title: "{{story_title}}"
 # Execution summary
 execution:
  started_at: "{{started_at}}"
  completed_at: "{{completed_at}}"
  total_duration: "{{duration}}"
  mode: "{{mode}}"
  status: "{{status}}"
 # Agent roles used
 agents:
  sm:
    name: "Scrum Master"
    steps: [2, 3, 7]
    total_time: null
  tea:
    name: "Test Engineering Architect"
    steps: [4]
    total_time: null
  dev:
    name: "Developer"
    steps: [5, 6]
    total_time: null
 # Step-by-step execution log
 steps:
  - step: 1
    name: "Initialize"
    status: "{{status}}"
    duration: "{{duration}}"
    actions:
      - "Loaded project context"
      - "Loaded epic definition"
      - "Cached architecture sections"
  - step: 2
    name: "Create Story"
    status: "{{status}}"
    duration: "{{duration}}"
    agent: "sm"
    research_queries:
      - "{{query_1}}"
      - "{{query_2}}"
    output: "{{story_file_path}}"
    acceptance_criteria_count: {{count}}
  - step: 3
    name: "Validate Story"
    status: "{{status}}"
    duration: "{{duration}}"
    agent: "sm"
    issues_found: {{count}}
    issues_fixed: {{count}}
    quality_score: {{score}}
    validation_areas:
      - "AC structure"
      - "Testability"
      - "Technical feasibility"
      - "Edge cases"
  - step: 4
    name: "ATDD (Red Phase)"
    status: "{{status}}"
    duration: "{{duration}}"
    agent: "tea"
    tests_created: {{count}}
    test_files:
      - "{{path}}"
    factories_created:
      - "{{factory}}"
    fixtures_created:
      - "{{fixture}}"
    data_testids_documented: {{count}}
  - step: 5
    name: "Implement (Green Phase)"
    status: "{{status}}"
    duration: "{{duration}}"
    agent: "dev"
    files_modified: {{count}}
    migrations_applied:
      - "{{migration}}"
    test_results:
      passed: {{count}}
      failed: 0
    lint_status: "clean"
    build_status: "success"
  - step: 6
    name: "Code Review"
    status: "{{status}}"
    duration: "{{duration}}"
    agent: "dev"
    review_type: "adversarial"
    issues_found: {{count}}
    issues_fixed: {{count}}
    categories_reviewed:
      security:
        issues: {{count}}
        fixed: {{count}}
      performance:
        issues: {{count}}
        fixed: {{count}}
      error_handling:
        issues: {{count}}
        fixed: {{count}}
      testing:
        issues: {{count}}
        fixed: {{count}}
      code_quality:
        issues: {{count}}
        fixed: {{count}}
      architecture:
        issues: {{count}}
        fixed: {{count}}
  - step: 7
    name: "Complete"
    status: "{{status}}"
    duration: "{{duration}}"
    agent: "sm"
    commit_hash: "{{hash}}"
    commit_message: "feat(epic-{{epic_num}}): complete story {{story_id}}"
    files_committed: {{count}}
    sprint_status_updated: true
  - step: 8
    name: "Summary"
    status: "{{status}}"
    duration: "{{duration}}"
    audit_file: "{{this_file}}"
 # Quality gates summary
 quality_gates:
  story_creation:
    passed: true
    criteria:
      - "Story file created"
      - "All AC in BDD format"
      - "Test scenarios defined"
  validation:
    passed: true
    quality_score: {{score}}
    criteria:
      - "No ambiguous requirements"
      - "All issues fixed"
  atdd:
    passed: true
    criteria:
      - "Tests for all AC"
      - "Tests fail (red phase)"
      - "data-testids documented"
  implementation:
    passed: true
    criteria:
      - "All tests pass"
      - "Lint clean"
      - "Build success"
      - "RLS policies added"
  code_review:
    passed: true
    issues_found: {{count}}
    criteria:
      - "Minimum 3 issues found"
      - "All issues fixed"
      - "All categories reviewed"
 # Artifacts produced
 artifacts:
  story_file:
    path: "{{path}}"
    size: "{{size}}"
  test_files:
    - path: "{{path}}"
      test_count: {{count}}
  migrations:
    - path: "{{path}}"
      tables_affected: ["{{table}}"]
  checklists:
    atdd: "{{path}}"
    review: "{{path}}"
  commit:
    hash: "{{hash}}"
    branch: "{{branch}}"
    pushed: false
 # Token efficiency comparison
 token_efficiency:
  traditional_approach:
    description: "6 separate claude -p calls"
    estimated_tokens: 71000
    breakdown:
      - stage: "create-story"
        tokens: 12000
      - stage: "validate-story"
        tokens: 11000
      - stage: "atdd"
        tokens: 12000
      - stage: "implement"
        tokens: 15000
      - stage: "code-review"
        tokens: 13000
      - stage: "complete"
        tokens: 8000
  step_file_approach:
    description: "Single session with step-file loading"
    estimated_tokens: "{{actual}}"
    savings_percentage: "{{percentage}}"
    breakdown:
      - step: "context_loading"
        tokens: 5000
        note: "Loaded once, cached"
      - step: "step_files"
        tokens: "{{tokens}}"
        note: "~200 lines each"
      - step: "execution"
        tokens: "{{tokens}}"
        note: "Actual work"
 # Notes and observations
 notes:
  - "{{note_1}}"
  - "{{note_2}}"
 # Generated by
 generated_by: "BMAD Story Pipeline v2.0"
 generated_at: "{{timestamp}}"
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/templates/pipeline-state.yaml
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/templates/pipeline-state.yaml
@ -0,0 +1,144 @@
 # Pipeline State Template
 # Copy and populate for each story execution
 # Location: {sprint_artifacts}/pipeline-state-{story_id}.yaml
 ---
 # Story identification
 story_id: "{{story_id}}"
 epic_num: {{epic_num}}
 story_num: {{story_num}}
 # Execution mode
 mode: "interactive"  # or "batch"
 # Progress tracking
 stepsCompleted: []
 lastStep: 0
 currentStep: 0
 status: "not_started"  # not_started, initializing, in_progress, completing, completed, failed
 # Timestamps
 started_at: null
 updated_at: null
 completed_at: null
 # Cached document context (loaded once, reused)
 cached_context:
  project_context_loaded: false
  project_context_path: null
  epic_loaded: false
  epic_path: null
  architecture_sections: []
  architecture_paths: []
  story_file_exists: false
  story_file_path: null
 # Step status tracking
 steps:
  step-01-init:
    status: pending
    started_at: null
    completed_at: null
    duration: null
    notes: null
  step-02-create-story:
    status: pending
    started_at: null
    completed_at: null
    duration: null
    agent: sm
    output_file: null
    notes: null
  step-03-validate-story:
    status: pending
    started_at: null
    completed_at: null
    duration: null
    agent: sm
    issues_found: 0
    issues_fixed: 0
    quality_score: null
    notes: null
  step-04-atdd:
    status: pending
    started_at: null
    completed_at: null
    duration: null
    agent: tea
    tests_created: 0
    test_files: []
    factories_created: []
    fixtures_created: []
    notes: null
  step-05-implement:
    status: pending
    started_at: null
    completed_at: null
    duration: null
    agent: dev
    files_modified: []
    migrations_applied: []
    tests_passing: null
    lint_clean: null
    build_success: null
    notes: null
  step-06-code-review:
    status: pending
    started_at: null
    completed_at: null
    duration: null
    agent: dev
    issues_found: 0
    issues_fixed: 0
    categories_reviewed: []
    tests_passing: null
    notes: null
  step-07-complete:
    status: pending
    started_at: null
    completed_at: null
    duration: null
    agent: sm
    commit_hash: null
    sprint_status_updated: false
    notes: null
  step-08-summary:
    status: pending
    started_at: null
    completed_at: null
    duration: null
    audit_file: null
    notes: null
 # Error tracking (if pipeline fails)
 errors: []
 # Example error entry:
 # - step: 5
 #   timestamp: "2025-01-15T12:00:00Z"
 #   error: "Tests failed after implementation"
 #   details: "3 tests failing in auth.test.ts"
 #   recoverable: true
 # Quality gates passed
 quality_gates:
  story_creation: null
  validation: null
  atdd: null
  implementation: null
  code_review: null
 # Metrics (populated at end)
 metrics:
  total_duration: null
  token_estimate: null
  files_modified_count: 0
  tests_created_count: 0
  issues_found_total: 0
  issues_fixed_total: 0
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/workflow.md
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/workflow.md
@ -0,0 +1,265 @@
 ---
 name: story-pipeline
 description: Automated story development pipeline with token-efficient step-file architecture. Single-session orchestration replacing multiple Claude calls.
 web_bundle: true
 ---
 # Story Pipeline Workflow
 **Goal:** Execute complete story development lifecycle in a single Claude session: create story, validate, generate tests (ATDD), implement, code review, and complete.
 **Your Role:** You are the **BMAD Pipeline Orchestrator**. You will switch between agent roles (SM, TEA, DEV) as directed by each step file. Maintain context across role switches without reloading agent personas.
 **Token Efficiency:** This workflow uses step-file architecture for ~60-70% token savings compared to separate Claude calls.
 ---
 ## WORKFLOW ARCHITECTURE
 This uses **step-file architecture** for disciplined execution:
 ### Core Principles
 - **Micro-file Design**: Each step is a self-contained instruction file (~150-250 lines)
 - **Just-In-Time Loading**: Only the current step file is in memory
 - **Role Switching**: Same session, explicit role switch instead of fresh Claude calls
 - **State Tracking**: Pipeline state in `{sprint_artifacts}/pipeline-state-{story_id}.yaml`
 - **Checkpoint/Resume**: Can resume from any completed step after failure
 ### Step Processing Rules
 1. **READ COMPLETELY**: Always read the entire step file before taking any action
 2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
 3. **ROLE SWITCH**: When step specifies a role, adopt that agent's perspective
 4. **QUALITY GATES**: Complete gate criteria before proceeding to next step
 5. **WAIT FOR INPUT**: In interactive mode, halt at menus and wait for user selection
 6. **SAVE STATE**: Update pipeline state file after each step completion
 7. **LOAD NEXT**: When directed, load, read entire file, then execute the next step
 ### Critical Rules (NO EXCEPTIONS)
 - **NEVER** load multiple step files simultaneously
 - **ALWAYS** read entire step file before execution
 - **NEVER** skip steps or optimize the sequence
 - **ALWAYS** update pipeline state after completing each step
 - **ALWAYS** follow the exact instructions in the step file
 - **NEVER** create mental todo lists from future steps
 - **NEVER** look ahead to future step files
 ### Mode Differences
 | Aspect | Interactive | Batch |
 |--------|-------------|-------|
 | Menus | Present, wait for [C] | Auto-proceed |
 | Approval | Required at gates | Skip with YOLO |
 | On failure | Halt, checkpoint | Checkpoint, exit |
 | Code review | Same session | Fresh context option |
 ---
 ## EXECUTION MODES
 ### Interactive Mode (Default)
 ```bash
 bmad build 1-4          # Interactive pipeline for story 1-4
 bmad build --interactive 1-4
 ```
 Features:
 - Menu navigation between steps
 - User approval at quality gates
 - Can pause and resume
 - Role switching in same session
 ### Batch Mode
 ```bash
 bmad build --batch 1-4  # Unattended execution
 ```
 Features:
 - Auto-proceed through all steps
 - YOLO mode for approvals
 - Fail-fast on errors
 - Optional fresh context for code review
 ---
 ## INITIALIZATION SEQUENCE
 ### 1. Configuration Loading
 Load and read config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
 - `output_folder`, `sprint_artifacts`, `communication_language`
 ### 2. Pipeline Parameters
 Resolve from invocation:
 - `story_id`: Story identifier (e.g., "1-4")
 - `epic_num`: Epic number (e.g., 1)
 - `story_num`: Story number (e.g., 4)
 - `mode`: "interactive" or "batch"
 ### 3. Document Pre-loading
 Load and cache these documents (read once, use across steps):
 - Story file: `{sprint_artifacts}/story-{epic_num}-{story_num}.md`
 - Epic file: `{output_folder}/epic-{epic_num}.md`
 - Architecture: `{output_folder}/architecture.md` (selective sections)
 - Project context: `**/project-context.md`
 ### 4. First Step Execution
 Load, read the full file and then execute:
 `{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline/steps/step-01-init.md`
 ---
 ## STEP FILE MAP
 | Step | File | Agent | Purpose |
 |------|------|-------|---------|
 | 1 | step-01-init.md | - | Load context, detect mode, cache docs |
 | 1b | step-01b-resume.md | - | Resume from checkpoint (conditional) |
 | 2 | step-02-create-story.md | SM | Create detailed story with research |
 | 3 | step-03-validate-story.md | SM | Adversarial validation |
 | 4 | step-04-atdd.md | TEA | Generate failing tests (red phase) |
 | 5 | step-05-implement.md | DEV | Implement to pass tests (green phase) |
 | 6 | step-06-code-review.md | DEV | Find 3-10 specific issues |
 | 7 | step-07-complete.md | SM | Update status, git commit |
 | 8 | step-08-summary.md | - | Audit trail, summary report |
 ---
 ## ROLE SWITCHING PROTOCOL
 When a step requires a different agent role:
 1. **Announce Role Switch**: "Switching to [ROLE] perspective..."
 2. **Adopt Mindset**: Think from that role's expertise
 3. **Apply Checklist**: Use role-specific checklist from `checklists/`
 4. **Maintain Context**: Keep cached documents in memory
 5. **Complete Step**: Finish all step requirements before switching
 Example role switches:
 - Step 2-3: SM (story creation and validation)
 - Step 4: SM → TEA (switch to test mindset)
 - Step 5-6: TEA → DEV (switch to implementation mindset)
 - Step 7: DEV → SM (switch back for completion)
 ---
 ## STATE MANAGEMENT
 ### Pipeline State File
 Location: `{sprint_artifacts}/pipeline-state-{story_id}.yaml`
 ```yaml
 story_id: "1-4"
 epic_num: 1
 story_num: 4
 mode: "interactive"
 stepsCompleted: [1, 2, 3]
 lastStep: 3
 currentStep: 4
 status: "in_progress"
 started_at: "2025-01-15T10:00:00Z"
 updated_at: "2025-01-15T11:30:00Z"
 cached_context:
  story_loaded: true
  epic_loaded: true
  architecture_sections: ["tech_stack", "data_model"]
 steps:
  step-01-init: { status: completed, duration: "0:02:15" }
  step-02-create-story: { status: completed, duration: "0:15:30" }
  step-03-validate-story: { status: completed, duration: "0:08:45" }
  step-04-atdd: { status: in_progress }
  step-05-implement: { status: pending }
  step-06-code-review: { status: pending }
  step-07-complete: { status: pending }
  step-08-summary: { status: pending }
 ```
 ### Checkpoint/Resume
 To resume after failure:
 ```bash
 bmad build --resume 1-4
 ```
 Resume logic:
 1. Load state file for story 1-4
 2. Find `lastStep` completed
 3. Load and execute step `lastStep + 1`
 4. Continue from there
 ---
 ## QUALITY GATES
 Each gate must pass before proceeding:
 ### Story Creation Gate (Step 2)
 - [ ] Story file created with proper frontmatter
 - [ ] All acceptance criteria defined with Given/When/Then
 - [ ] Technical context linked
 ### Validation Gate (Step 3)
 - [ ] Story passes adversarial review
 - [ ] No ambiguous requirements
 - [ ] Implementation path clear
 ### ATDD Gate (Step 4)
 - [ ] Tests exist for all acceptance criteria
 - [ ] Tests fail (red phase verified)
 - [ ] Test structure follows project patterns
 ### Implementation Gate (Step 5)
 - [ ] All tests pass (green phase)
 - [ ] Code follows project patterns
 - [ ] No TypeScript errors
 - [ ] Lint passes
 ### Code Review Gate (Step 6)
 - [ ] 3-10 specific issues identified (not "looks good")
 - [ ] All issues resolved or documented
 - [ ] Security review complete
 ---
 ## SUCCESS METRICS
 ### ✅ SUCCESS
 - Pipeline completes all 8 steps
 - All quality gates passed
 - Story status updated to "done"
 - Git commit created
 - Audit trail generated
 - Token usage < 35K (target)
 ### ❌ FAILURE
 - Step file instructions skipped or optimized
 - Quality gate bypassed without approval
 - Role not properly switched
 - State file not updated
 - Tests not verified to fail before implementation
 - Code review accepts "looks good"
 ---
 ## AUDIT TRAIL
 After completion, generate audit trail at:
 `{sprint_artifacts}/audit-{story_id}-{date}.yaml`
 Contents:
 - Pipeline execution timeline
 - Step durations
 - Quality gate results
 - Issues found and resolved
 - Files modified
 - Token usage estimate
--- a/src/modules/bmm/workflows/4-implementation/story-pipeline/workflow.yaml
+++ b/src/modules/bmm/workflows/4-implementation/story-pipeline/workflow.yaml
@ -0,0 +1,219 @@
 name: story-pipeline
 description: "Automated story development pipeline with token-efficient step-file architecture. Replaces separate Claude calls with single-session orchestration."
 author: "BMad + digital-bridge"
 version: "2.0.0"
 # Critical variables from config
 config_source: "{project-root}/_bmad/bmm/config.yaml"
 output_folder: "{config_source}:output_folder"
 sprint_artifacts: "{config_source}:sprint_artifacts"
 communication_language: "{config_source}:communication_language"
 date: system-generated
 # Workflow paths
 installed_path: "{project-root}/_bmad/bmm/workflows/4-implementation/story-pipeline"
 steps_path: "{installed_path}/steps"
 templates_path: "{installed_path}/templates"
 checklists_path: "{installed_path}/checklists"
 # State management
 state_file: "{sprint_artifacts}/pipeline-state-{{story_id}}.yaml"
 audit_trail: "{sprint_artifacts}/audit-{{story_id}}-{{date}}.yaml"
 # Workflow modes
 modes:
  interactive:
    description: "Human-in-the-loop with menu navigation between steps"
    checkpoint_on_failure: true
    requires_approval: true
    fresh_context_for_review: false  # Role switch instead
  batch:
    description: "Unattended execution with YOLO mode"
    checkpoint_on_failure: true
    requires_approval: false
    fresh_context_for_review: true   # Checkpoint before code review
    fail_fast: true
 # Agent role definitions (loaded once, switched as needed)
 agents:
  sm:
    name: "Scrum Master"
    persona: "{project-root}/_bmad/bmm/agents/sm.md"
    description: "Story creation, validation, sprint status"
    used_in_steps: [2, 3, 7]
  tea:
    name: "Test Engineering Architect"
    persona: "{project-root}/_bmad/bmm/agents/tea.md"
    description: "ATDD test generation, red phase verification"
    used_in_steps: [4]
  dev:
    name: "Developer"
    persona: "{project-root}/_bmad/bmm/agents/dev.md"
    description: "Implementation, code review"
    used_in_steps: [5, 6]
 # Step file definitions
 steps:
  - step: 1
    file: "{steps_path}/step-01-init.md"
    name: "Initialize Pipeline"
    description: "Load story context, detect mode, cache documents"
    agent: null
    quality_gate: false
  - step: "1b"
    file: "{steps_path}/step-01b-resume.md"
    name: "Resume from Checkpoint"
    description: "Resume pipeline from last completed step"
    agent: null
    quality_gate: false
    conditional: true  # Only if resuming
  - step: 2
    file: "{steps_path}/step-02-create-story.md"
    name: "Create Story"
    description: "Generate detailed story from epic with research"
    agent: sm
    quality_gate: true
    mcp_tools: [exa]
    checklist: "{checklists_path}/story-creation.md"
  - step: 3
    file: "{steps_path}/step-03-validate-story.md"
    name: "Validate Story"
    description: "Adversarial validation of story completeness"
    agent: sm
    quality_gate: true
    checklist: "{checklists_path}/story-validation.md"
  - step: 4
    file: "{steps_path}/step-04-atdd.md"
    name: "ATDD Test Generation"
    description: "Generate failing acceptance tests (red phase)"
    agent: tea
    quality_gate: true
    checklist: "{checklists_path}/atdd.md"
  - step: 5
    file: "{steps_path}/step-05-implement.md"
    name: "Implement Story"
    description: "Implement code to pass tests (green phase)"
    agent: dev
    quality_gate: true
    checklist: "{checklists_path}/implementation.md"
  - step: 6
    file: "{steps_path}/step-06-code-review.md"
    name: "Code Review"
    description: "Adversarial code review finding 3-10 issues"
    agent: dev
    quality_gate: true
    requires_fresh_context: true  # In batch mode, checkpoint here
    checklist: "{checklists_path}/code-review.md"
  - step: 7
    file: "{steps_path}/step-07-complete.md"
    name: "Complete Story"
    description: "Update sprint status, create git commit"
    agent: sm
    quality_gate: false
  - step: 8
    file: "{steps_path}/step-08-summary.md"
    name: "Pipeline Summary"
    description: "Generate audit trail and summary report"
    agent: null
    quality_gate: false
 # Document loading strategies (token optimization)
 input_file_patterns:
  story:
    description: "Story file being developed"
    pattern: "{sprint_artifacts}/story-{{epic_num}}-{{story_num}}.md"
    load_strategy: "FULL_LOAD"
    cache: true  # Keep in memory across steps
  epics:
    description: "Epic definitions with BDD scenarios"
    whole: "{output_folder}/epic*.md"
    sharded: "{output_folder}/epics/*.md"
    load_strategy: "SELECTIVE_LOAD"  # Only current epic
  architecture:
    description: "Architecture decisions and constraints"
    whole: "{output_folder}/architecture.md"
    sharded: "{output_folder}/architecture/*.md"
    load_strategy: "INDEX_GUIDED"  # Use index for section selection
    sections_needed: ["tech_stack", "data_model", "api_patterns"]
  prd:
    description: "Product requirements"
    whole: "{output_folder}/prd.md"
    sharded: "{output_folder}/prd/*.md"
    load_strategy: "SELECTIVE_LOAD"  # Only relevant sections
  project_context:
    description: "Critical rules and patterns"
    pattern: "**/project-context.md"
    load_strategy: "FULL_LOAD"
    cache: true
 # MCP tool extensions
 mcp_extensions:
  exa:
    description: "Web search for research during story creation"
    used_in_steps: [2]
  supabase:
    description: "Database operations during implementation"
    used_in_steps: [5]
 # Quality gates (must pass to proceed)
 quality_gates:
  story_creation:
    step: 2
    criteria:
      - "Story file created with proper frontmatter"
      - "All acceptance criteria defined"
      - "Technical context linked"
  story_validation:
    step: 3
    criteria:
      - "Story passes adversarial review"
      - "No ambiguous requirements"
      - "Implementation path clear"
  atdd:
    step: 4
    criteria:
      - "Tests exist for all acceptance criteria"
      - "Tests fail (red phase verified)"
      - "Test structure follows project patterns"
  implementation:
    step: 5
    criteria:
      - "All tests pass (green phase)"
      - "Code follows project patterns"
      - "No TypeScript errors"
  code_review:
    step: 6
    criteria:
      - "3-10 specific issues identified"
      - "All issues resolved or documented"
      - "Security review complete"
 # Audit trail configuration
 audit:
  enabled: true
  output_file: "{audit_trail}"
  include:
    - timestamps
    - step_durations
    - quality_gate_results
    - issues_found
    - files_modified
    - token_usage
 standalone: true
Author	SHA1	Message	Date
Thomas	2e178df68d	Merge `ffda2938ff` into `c18904d674`	2026-01-11 02:57:44 +03:00
Thomas	ffda2938ff	Merge branch 'bmad-code-org:main' into feature/pipeline-step-file-architecture	2025-12-28 12:42:58 +01:00
Thomas Jetzinger	1347daa279	docs(story-pipeline): add comprehensive documentation Covers: - Problem statement and token efficiency gains - What each step automates (8-step workflow) - Usage: interactive, batch, and resume modes - Configuration options (workflow.yaml) - State management and checkpointing - Quality gates and adversarial mode - Troubleshooting and best practices - Comparison with legacy pipeline	2025-12-26 13:12:40 +01:00
Thomas Jetzinger	d2d6328be2	feat(bmm): add story-pipeline workflow for 60-70% token savings Single-session step-file architecture replacing 6 separate claude calls: Structure: - 8 step files (~200 lines each) with just-in-time loading - Role switching (SM → TEA → DEV) within session - State YAML for checkpoint/resume capability - Checklists for validation, ATDD, implementation, code review Steps: 1. Init - Load context, detect mode 2. Create Story - SM generates story from epic 3. Validate Story - Adversarial validation (find issues) 4. ATDD - TEA generates failing tests (RED phase) 5. Implement - DEV implements to pass tests (GREEN) 6. Code Review - Adversarial review (must find 3-10 issues) 7. Complete - Git commit, status update 8. Summary - Audit trail generation Token efficiency: - Legacy (6 calls): ~71K tokens/story - Interactive mode: ~25K tokens (~65% savings) - Batch mode: ~30K tokens (~58% savings) Tested with real story (1-4 User Invitation): 17 files, +2800 lines, context exhaustion mid-session recovered via state file.	2025-12-26 13:12:40 +01:00