bmad-elsabro 1.0.0

package/src/bmm/workflows/parallel-work/parallel-stories/workflow.md

@@ -0,0 +1,112 @@
+---
+name: parallel-stories
+description: 'Implement independent stories simultaneously - 3.5x speedup on sprints'
+---
+
+# Parallel Stories Workflow
+
+**Goal:** Implement multiple INDEPENDENT stories at the same time.
+
+**Speedup:** 3.5x faster sprint completion
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+1. Analyze story dependencies
+2. Group independent stories
+3. Launch parallel implementation streams
+4. Sync and integrate
+
+---
+
+## INITIALIZATION
+
+### Parallel Settings
+
+```yaml
+parallel_config:
+  mode: "stories"
+  max_concurrent: 4
+  dependency_check: true
+  conflict_strategy: "file-lock"
+```
+
+---
+
+## EXECUTION
+
+### Step 1: Load Stories
+
+From sprint or epic file, load all stories to implement.
+
+### Step 2: Dependency Analysis
+
+For each story, check:
+- Files it will modify
+- APIs it depends on
+- Database changes needed
+- Shared state affected
+
+Build dependency graph:
+```
+Story A: modifies auth.ts
+Story B: modifies dashboard.ts
+Story C: modifies auth.ts (CONFLICT with A)
+Story D: modifies api.ts
+
+Independent groups:
+- Group 1: [A, B, D] - can run in parallel
+- Group 2: [C] - must wait for A
+```
+
+### Step 3: Launch Parallel Streams
+
+For each independent group:
+
+**Parallel Stream per Story:**
+- Load story context
+- Invoke dev-story workflow
+- Track progress
+- Report completion
+
+### Step 4: Wave Execution
+
+```
+Wave 1: Stories A, B, D (parallel)
+  └─ Wait for completion
+Wave 2: Story C (depends on A)
+  └─ Wait for completion
+```
+
+### Step 5: Integration
+
+After all waves:
+- Run full test suite
+- Validate no regressions
+- Check integration points
+
+### Step 6: Report
+
+```
+✅ PARALLEL STORIES COMPLETE
+
+📊 Sprint Summary:
+- Stories: {total}
+- Waves: {wave_count}
+- Parallelism: {max_concurrent}
+
+⏱️ Time Analysis:
+- Sequential would take: {sequential_time}
+- Actual time: {actual_time}
+- Speedup: {speedup}x
+
+🧪 Tests: {passed}/{total}
+📁 Files changed: {count}
+```
+
+---
+
+## WORKFLOW COMPLETE
+
+Sprint completed in parallel. Multiple stories, one integration.

package/src/bmm/workflows/parallel-work/sprint-mode/steps/step-01-load-sprint.md

@@ -0,0 +1,54 @@
+---
+name: step-01-load-sprint
+description: Load sprint configuration and all stories to execute
+---
+
+# Step 1: Load Sprint
+
+## OBJECTIVE
+
+Load the sprint/epic and all stories that need to be implemented.
+
+## EXECUTION
+
+### 1. Identify Sprint Source
+
+Load from one of:
+- `sprint-status.yaml` if exists (resume sprint)
+- Epic file with stories
+- User-specified story list
+
+### 2. Parse All Stories
+
+For each story, extract:
+- Story ID and title
+- Acceptance criteria
+- Task breakdown
+- Dependencies on other stories
+- Estimated complexity
+
+### 3. Validate Stories
+
+Check that each story has:
+- [ ] Clear acceptance criteria
+- [ ] Task breakdown
+- [ ] No circular dependencies
+
+### 4. Create Sprint Manifest
+
+```yaml
+sprint_id: "SPRINT-{date}"
+total_stories: {count}
+stories:
+  - id: "STORY-001"
+    title: "{title}"
+    complexity: "small|medium|large"
+    dependencies: []
+    status: "pending"
+  - id: "STORY-002"
+    ...
+```
+
+## NEXT STEP
+
+Proceed to: `step-02-plan-execution.md`

package/src/bmm/workflows/parallel-work/sprint-mode/steps/step-02-plan-execution.md

@@ -0,0 +1,63 @@
+---
+name: step-02-plan-execution
+description: Plan optimal execution order considering dependencies and parallelization
+---
+
+# Step 2: Plan Execution
+
+## OBJECTIVE
+
+Create optimal execution plan that maximizes parallelization while respecting dependencies.
+
+## EXECUTION
+
+### 1. Build Dependency Graph
+
+Map which stories depend on which:
+
+```
+STORY-001 (Auth) ─┐
+                  ├─→ STORY-003 (Dashboard - needs Auth)
+STORY-002 (API)  ─┘
+STORY-004 (UI) ─────→ Independent
+```
+
+### 2. Identify Parallel Groups (Waves)
+
+Group stories that can execute in parallel:
+
+```
+Wave 1: [STORY-001, STORY-002, STORY-004] - No dependencies
+Wave 2: [STORY-003] - Depends on Wave 1
+```
+
+### 3. Estimate Total Time
+
+Calculate:
+- Sequential time: Sum of all story estimates
+- Parallel time: Max time per wave × number of waves
+- Expected speedup: Sequential / Parallel
+
+### 4. Generate Execution Plan
+
+```yaml
+execution_plan:
+  waves:
+    - wave: 1
+      stories: ["STORY-001", "STORY-002", "STORY-004"]
+      parallel: true
+      estimated_time: "4h"
+    - wave: 2
+      stories: ["STORY-003"]
+      parallel: false
+      estimated_time: "2h"
+
+  totals:
+    sequential_estimate: "14h"
+    parallel_estimate: "6h"
+    expected_speedup: "2.3x"
+```
+
+## NEXT STEP
+
+Proceed to: `step-03-execute-stories.md`

package/src/bmm/workflows/parallel-work/sprint-mode/steps/step-03-execute-stories.md

@@ -0,0 +1,112 @@
+---
+name: step-03-execute-stories
+description: Auto-execute all stories following the execution plan
+---
+
+# Step 3: Execute Stories
+
+## OBJECTIVE
+
+Execute all stories automatically, respecting wave order and parallelization settings.
+
+## EXECUTION
+
+### 1. Initialize Execution Context
+
+```yaml
+execution_state:
+  current_wave: 1
+  stories_completed: 0
+  stories_failed: 0
+  start_time: "{timestamp}"
+```
+
+### 2. Execute Wave by Wave
+
+For each wave in execution_plan:
+
+#### 2.1 Start Wave
+
+```
+┌─────────────────────────────────────────────────┐
+│ WAVE {n} - Starting {count} stories             │
+│ Mode: {parallel|sequential}                     │
+└─────────────────────────────────────────────────┘
+```
+
+#### 2.2 Execute Stories in Wave
+
+For each story (parallel if configured):
+
+```
+┌─────────────────────────────────────┐
+│ Story: {story_id} - {title}         │
+├─────────────────────────────────────┤
+│ Status: Starting...                 │
+│ → Loading story context             │
+│ → Implementing tasks                │
+│ → Running unit tests                │
+│ → Complete (12 min)                 │
+└─────────────────────────────────────┘
+```
+
+**Story Execution Flow:**
+1. Load story file and acceptance criteria
+2. Invoke `story-implementation` workflow for the story
+3. Capture implementation results
+4. Run story-specific tests
+5. Update sprint status
+
+#### 2.3 Handle Failures
+
+If story fails:
+1. Log detailed error
+2. Check retry configuration
+3. If `retry_failed: true` and retries < `max_retries`:
+   - Wait briefly
+   - Retry story execution
+4. If still failing:
+   - Mark story as `failed`
+   - If `stop_on_error: false`, continue to next story
+   - If `stop_on_error: true`, halt sprint
+
+### 3. Update Sprint Status
+
+After each story completion:
+
+```yaml
+# sprint-status.yaml
+sprint_id: "SPRINT-{date}"
+status: "in_progress"
+current_wave: 2
+stories:
+  - id: "STORY-001"
+    status: "completed"
+    duration: "12m"
+    tests_passed: 15
+    tests_failed: 0
+  - id: "STORY-002"
+    status: "failed"
+    error: "Test assertion failed in user.test.js"
+    retries: 2
+  - id: "STORY-003"
+    status: "pending"
+```
+
+### 4. Wave Completion
+
+After all stories in wave complete:
+- Verify all dependencies satisfied
+- Run integration check between wave stories
+- Proceed to next wave
+
+### 5. Sprint Completion Check
+
+When all waves complete:
+- Calculate total execution time
+- Summarize completed vs failed stories
+- Prepare for code review phase
+
+## NEXT STEP
+
+Proceed to: `step-04-code-review.md`

package/src/bmm/workflows/parallel-work/sprint-mode/steps/step-04-code-review.md

@@ -0,0 +1,148 @@
+---
+name: step-04-code-review
+description: Run automated code reviews on all completed stories
+---
+
+# Step 4: Code Review
+
+## OBJECTIVE
+
+Perform automated code review on all successfully implemented stories to ensure code quality.
+
+## EXECUTION
+
+### 1. Check Review Mode
+
+From `sprint_config.code_review_mode`:
+- `auto`: Run automated review, auto-fix minor issues
+- `manual`: Generate review report for human review
+- `skip`: Skip code review phase entirely
+
+If mode is `skip`, proceed directly to step 5.
+
+### 2. Collect Files to Review
+
+For each completed story:
+- Identify all files created/modified
+- Group by file type (source, test, config)
+- Prioritize core business logic files
+
+```yaml
+review_scope:
+  story_001:
+    files_changed: 8
+    source_files: ["src/auth/login.ts", "src/auth/session.ts"]
+    test_files: ["tests/auth/login.test.ts"]
+    config_files: ["config/auth.yaml"]
+  story_002:
+    ...
+```
+
+### 3. Run Automated Reviews
+
+For each file, check:
+
+#### 3.1 Code Quality
+- [ ] Follows project coding standards
+- [ ] No code duplication (DRY violations)
+- [ ] Functions/methods not too long (< 50 lines)
+- [ ] Appropriate naming conventions
+- [ ] Proper error handling
+
+#### 3.2 Security
+- [ ] No hardcoded secrets or credentials
+- [ ] Input validation present
+- [ ] No SQL injection vulnerabilities
+- [ ] Proper authentication checks
+- [ ] Sensitive data not logged
+
+#### 3.3 Performance
+- [ ] No N+1 query patterns
+- [ ] Appropriate use of caching
+- [ ] No blocking operations in async code
+- [ ] Efficient algorithms used
+
+#### 3.4 Test Coverage
+- [ ] Unit tests for new functions
+- [ ] Edge cases covered
+- [ ] Mocks used appropriately
+- [ ] Integration tests where needed
+
+### 4. Categorize Issues
+
+```yaml
+review_results:
+  critical:  # Must fix before merge
+    - file: "src/auth/login.ts"
+      line: 45
+      issue: "Password logged in plain text"
+      severity: "critical"
+      auto_fix: false
+
+  major:  # Should fix
+    - file: "src/api/users.ts"
+      line: 23
+      issue: "Missing input validation"
+      severity: "major"
+      auto_fix: true
+
+  minor:  # Nice to fix
+    - file: "src/utils/helpers.ts"
+      line: 12
+      issue: "Variable name not descriptive"
+      severity: "minor"
+      auto_fix: true
+```
+
+### 5. Auto-Fix (if enabled)
+
+For issues marked `auto_fix: true`:
+1. Apply automated fix
+2. Re-run tests to verify
+3. Log fix applied
+
+```
+Auto-fixed 5 minor issues:
+  - Formatting in 3 files
+  - Added missing type annotations
+  - Improved variable names
+```
+
+### 6. Generate Review Report
+
+```markdown
+## Code Review Summary
+
+### Stories Reviewed: {count}
+### Files Analyzed: {count}
+
+### Issues Found
+| Severity | Count | Auto-Fixed |
+|----------|-------|------------|
+| Critical | 1     | 0          |
+| Major    | 3     | 2          |
+| Minor    | 8     | 7          |
+
+### Critical Issues (Manual Review Required)
+1. **src/auth/login.ts:45** - Password logged in plain text
+   - Recommendation: Remove logging statement or mask password
+
+### Action Required
+- Fix 1 critical issue before merge
+- Review 1 major issue
+```
+
+### 7. Update Sprint Status
+
+```yaml
+code_review:
+  status: "completed"
+  issues_found: 12
+  auto_fixed: 9
+  manual_review_needed: 3
+  critical_issues: 1
+```
+
+## NEXT STEP
+
+Proceed to: `step-05-integration-testing.md`

package/src/bmm/workflows/parallel-work/sprint-mode/steps/step-05-integration-testing.md

@@ -0,0 +1,200 @@
+---
+name: step-05-integration-testing
+description: Run full integration testing across all implemented stories
+---
+
+# Step 5: Integration Testing
+
+## OBJECTIVE
+
+Validate that all implemented stories work together correctly and no regressions were introduced.
+
+## EXECUTION
+
+### 1. Prepare Test Environment
+
+Ensure test environment is ready:
+- Database seeded with test data
+- Mock services configured
+- Environment variables set
+- Test isolation enabled
+
+```yaml
+test_environment:
+  database: "test_db"
+  mock_services: true
+  isolation: "transaction_rollback"
+  parallel_tests: true
+```
+
+### 2. Run Test Suites
+
+#### 2.1 Unit Tests (Full Suite)
+
+Run all unit tests, not just story-specific:
+
+```
+Running unit tests...
+  ✓ auth/login.test.ts (15 tests)
+  ✓ auth/session.test.ts (8 tests)
+  ✓ api/users.test.ts (12 tests)
+  ✓ utils/helpers.test.ts (20 tests)
+  ...
+
+Unit Tests: 156 passed, 0 failed
+Duration: 45s
+```
+
+#### 2.2 Integration Tests
+
+Test interactions between components:
+
+```
+Running integration tests...
+  ✓ Auth flow end-to-end
+  ✓ API authentication middleware
+  ✓ Database transactions
+  ✓ Cache invalidation
+  ...
+
+Integration Tests: 24 passed, 0 failed
+Duration: 2m 15s
+```
+
+#### 2.3 E2E Tests (if available)
+
+Run end-to-end tests:
+
+```
+Running E2E tests...
+  ✓ User registration flow
+  ✓ Login and dashboard access
+  ✓ Data CRUD operations
+  ...
+
+E2E Tests: 12 passed, 0 failed
+Duration: 5m 30s
+```
+
+### 3. Regression Check
+
+Compare test results with baseline:
+
+```yaml
+regression_check:
+  baseline_tests: 180
+  current_tests: 192
+  new_tests: 12
+  removed_tests: 0
+
+  baseline_coverage: "78%"
+  current_coverage: "82%"
+  coverage_delta: "+4%"
+
+  regressions_found: 0
+```
+
+### 4. Cross-Story Integration
+
+Verify stories work together:
+
+| Story A | Story B | Integration Point | Status |
+|---------|---------|-------------------|--------|
+| Auth    | API     | Token validation  | Pass   |
+| API     | Dashboard | Data fetching   | Pass   |
+| Auth    | Dashboard | Session mgmt    | Pass   |
+
+### 5. Performance Baseline
+
+Run performance checks:
+
+```yaml
+performance_check:
+  api_response_times:
+    p50: "45ms"
+    p95: "120ms"
+    p99: "250ms"
+
+  database_queries:
+    avg_query_time: "12ms"
+    slow_queries: 0
+
+  memory_usage:
+    baseline: "256MB"
+    current: "268MB"
+    delta: "+4.7%"
+```
+
+### 6. Handle Test Failures
+
+If tests fail:
+
+1. **Identify failing tests**
+   - Which story introduced the failure?
+   - Is it a new test or regression?
+
+2. **Categorize failure**
+   - Flaky test (retry)
+   - Genuine bug (needs fix)
+   - Test needs update (environment issue)
+
+3. **Action based on severity**
+   ```yaml
+   test_failures:
+     - test: "auth/session.test.ts"
+       type: "flaky"
+       action: "retry"
+       result: "passed_on_retry"
+
+     - test: "api/users.test.ts"
+       type: "genuine_bug"
+       action: "flag_for_review"
+       blocking: true
+   ```
+
+### 7. Generate Test Report
+
+```markdown
+## Integration Test Report
+
+### Summary
+- **Total Tests:** 192
+- **Passed:** 190
+- **Failed:** 0
+- **Skipped:** 2
+- **Duration:** 8m 30s
+
+### Coverage
+- **Line Coverage:** 82% (+4%)
+- **Branch Coverage:** 75% (+2%)
+- **Function Coverage:** 88% (+3%)
+
+### Performance
+- API Response (p95): 120ms (within threshold)
+- No slow queries detected
+- Memory usage acceptable
+
+### Cross-Story Integration
+All integration points validated successfully.
+
+### Verdict: PASS
+All tests passing. Ready for sprint report.
+```
+
+### 8. Update Sprint Status
+
+```yaml
+integration_testing:
+  status: "completed"
+  total_tests: 192
+  passed: 190
+  failed: 0
+  skipped: 2
+  coverage: "82%"
+  performance: "acceptable"
+  verdict: "pass"
+```
+
+## NEXT STEP
+
+Proceed to: `step-06-sprint-report.md`