bmad-method-test-architecture-enterprise 1.2.2 → 1.2.3

package/src/workflows/testarch/atdd/steps-c/step-01-preflight-and-context.md

@@ -37,17 +37,36 @@ Verify prerequisites and load all required inputs before generating failing test
 
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
 
-## 1. Prerequisites (Hard Requirements)
+## 1. Stack Detection
+
+**Read `config.test_stack_type`** from `{config_source}`.
+
+**Auto-Detection Algorithm** (when `test_stack_type` is `"auto"` or not configured):
+
+- Scan `{project-root}` for project manifests:
+  - **Frontend indicators**: `package.json` with react/vue/angular/next dependencies, `playwright.config.*`, `vite.config.*`, `webpack.config.*`
+  - **Backend indicators**: `pyproject.toml`, `pom.xml`/`build.gradle`, `go.mod`, `*.csproj`/`*.sln`, `Gemfile`, `Cargo.toml`
+  - **Both present** = `fullstack`; only frontend = `frontend`; only backend = `backend`
+- Explicit `test_stack_type` config value overrides auto-detection
+- **Backward compatibility**: if `test_stack_type` is not in config, treat as `"auto"` (preserves current frontend behavior for existing installs)
+
+Store result as `{detected_stack}` = `frontend` | `backend` | `fullstack`
+
+---
+
+## 2. Prerequisites (Hard Requirements)
 
 - Story approved with **clear acceptance criteria**
-- Test framework configured (`playwright.config.ts` or `cypress.config.ts`)
+- Test framework configured:
+  - **If {detected_stack} is `frontend` or `fullstack`:** `playwright.config.ts` or `cypress.config.ts`
+  - **If {detected_stack} is `backend`:** relevant test config exists (e.g., `conftest.py`, `src/test/`, `*_test.go`, `.rspec`)
 - Development environment available
 
 If any are missing: **HALT** and notify the user.
 
 ---
 
-## 2. Load Story Context
+## 3. Load Story Context
 
 - Read story markdown from `{story_file}` (or ask user if not provided)
 - Extract acceptance criteria and constraints
@@ -55,21 +74,44 @@ If any are missing: **HALT** and notify the user.
 
 ---
 
-## 3. Load Framework & Existing Patterns
+## 4. Load Framework & Existing Patterns
 
 - Read framework config
 - Inspect `{test_dir}` for existing test patterns, fixtures, helpers
 
-## 3.5 Read TEA Config Flags
+## 4.5 Read TEA Config Flags
 
 From `{config_source}`:
 
 - `tea_use_playwright_utils`
 - `tea_browser_automation`
+- `test_stack_type`
 
 ---
 
-## 4. Load Knowledge Base Fragments
+### Tiered Knowledge Loading
+
+Load fragments based on their `tier` classification in `tea-index.csv`:
+
+1. **Core tier** (always load): Foundational fragments required for this workflow
+2. **Extended tier** (load on-demand): Load when deeper analysis is needed or when the user's context requires it
+3. **Specialized tier** (load only when relevant): Load only when the specific use case matches (e.g., contract-testing only for microservices, email-auth only for email flows)
+
+> **Context Efficiency**: Loading only core fragments reduces context usage by 40-50% compared to loading all fragments.
+
+### Playwright Utils Loading Profiles
+
+**If `tea_use_playwright_utils` is enabled**, select the appropriate loading profile:
+
+- **API-only profile** (when `{detected_stack}` is `backend` or no `page.goto`/`page.locator` found in test files):
+  Load: `overview`, `api-request`, `auth-session`, `recurse` (~1,800 lines)
+
+- **Full UI+API profile** (when `{detected_stack}` is `frontend`/`fullstack` or browser tests detected):
+  Load: all Playwright Utils core fragments (~4,500 lines)
+
+**Detection**: Scan `{test_dir}` for files containing `page.goto` or `page.locator`. If none found, use API-only profile.
+
+## 5. Load Knowledge Base Fragments
 
 Use `{knowledgeIndex}` to load:
 
@@ -79,35 +121,44 @@ Use `{knowledgeIndex}` to load:
 - `component-tdd.md`
 - `test-quality.md`
 - `test-healing-patterns.md`
+
+**If {detected_stack} is `frontend` or `fullstack`:**
+
 - `selector-resilience.md`
 - `timing-debugging.md`
 
-**Playwright Utils (if enabled):**
+**Playwright Utils (if enabled and {detected_stack} is `frontend` or `fullstack`):**
 
 - `overview.md`, `api-request.md`, `network-recorder.md`, `auth-session.md`, `intercept-network-call.md`, `recurse.md`, `log.md`, `file-utils.md`, `network-error-monitor.md`, `fixtures-composition.md`
 
-**Playwright CLI (if tea_browser_automation is "cli" or "auto"):**
+**Playwright CLI (if tea_browser_automation is "cli" or "auto" and {detected_stack} is `frontend` or `fullstack`):**
 
 - `playwright-cli.md`
 
-**MCP Patterns (if tea_browser_automation is "mcp" or "auto"):**
+**MCP Patterns (if tea_browser_automation is "mcp" or "auto" and {detected_stack} is `frontend` or `fullstack`):**
 
 - (existing MCP-related fragments, if any are added in future)
 
-**Traditional Patterns (if utils disabled):**
+**Traditional Patterns (if utils disabled and {detected_stack} is `frontend` or `fullstack`):**
 
 - `fixture-architecture.md`
 - `network-first.md`
 
+**Backend Patterns (if {detected_stack} is `backend` or `fullstack`):**
+
+- `test-levels-framework.md`
+- `test-priorities-matrix.md`
+- `ci-burn-in.md`
+
 ---
 
-## 5. Confirm Inputs
+## 6. Confirm Inputs
 
 Summarize loaded inputs and confirm with the user. Then proceed.
 
 ---
 
-## 6. Save Progress
+## 7. Save Progress
 
 **Save this step's accumulated work to `{outputFile}`.**
 
@@ -129,6 +180,8 @@ Summarize loaded inputs and confirm with the user. Then proceed.
   - Set `lastSaved: '{date}'`
   - Append this step's output to the appropriate section.
 
+**Update `inputDocuments`**: Set `inputDocuments` in the output template frontmatter to the list of artifact paths loaded in this step (e.g., knowledge fragments, test design documents, configuration files).
+
 Load next step: `{nextStepFile}`
 
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS:

package/src/workflows/testarch/atdd/steps-c/step-02-generation-mode.md

@@ -41,6 +41,7 @@ Use AI generation when:
 
 - Acceptance criteria are clear
 - Scenarios are standard (CRUD, auth, API, navigation)
+- **If {detected_stack} is `backend`:** Always use AI generation (no browser recording needed)
 
 Proceed directly to test strategy if this applies.
 
@@ -48,6 +49,10 @@ Proceed directly to test strategy if this applies.
 
 ## 2. Optional Mode: Recording (Complex UI)
 
+**Skip this section entirely if {detected_stack} is `backend`.** For backend projects, use AI generation from API documentation, OpenAPI/Swagger specs, or source code analysis instead.
+
+**If {detected_stack} is `frontend` or `fullstack`:**
+
 Use recording when UI interactions need live browser verification.
 
 **Tool selection based on `config.tea_browser_automation`:**

package/src/workflows/testarch/atdd/steps-c/step-03-test-strategy.md

@@ -45,12 +45,21 @@ Translate acceptance criteria into a prioritized, level-appropriate test plan.
 
 ## 2. Select Test Levels
 
-Choose the best level per scenario:
+Choose the best level per scenario based on `{detected_stack}`:
+
+**If {detected_stack} is `frontend` or `fullstack`:**
 
 - **E2E** for critical user journeys
 - **API** for business logic and service contracts
 - **Component** for UI behavior
 
+**If {detected_stack} is `backend` or `fullstack`:**
+
+- **Unit** for pure functions, business logic, and edge cases
+- **Integration** for service interactions, database queries, and middleware
+- **API/Contract** for endpoint validation, request/response schemas, and Pact contracts
+- **No E2E** for pure backend projects (no browser-based testing needed)
+
 ---
 
 ## 3. Prioritize Tests

package/src/workflows/testarch/atdd/steps-c/step-05-validate-and-complete.md

@@ -50,7 +50,18 @@ Fix any gaps before completion.
 
 ---
 
-## 2. Completion Summary
+## 2. Polish Output
+
+Before finalizing, review the complete output document for quality:
+
+1. **Remove duplication**: Progressive-append workflow may have created repeated sections — consolidate
+2. **Verify consistency**: Ensure terminology, risk scores, and references are consistent throughout
+3. **Check completeness**: All template sections should be populated or explicitly marked N/A
+4. **Format cleanup**: Ensure markdown formatting is clean (tables aligned, headers consistent, no orphaned references)
+
+---
+
+## 3. Completion Summary
 
 Report:
 
@@ -61,7 +72,7 @@ Report:
 
 ---
 
-## 3. Save Progress
+## 4. Save Progress
 
 **Save this step's accumulated work to `{outputFile}`.**
 

package/src/workflows/testarch/automate/steps-c/step-01-preflight-and-context.md

@@ -37,13 +37,32 @@ Determine execution mode, verify framework readiness, and load the necessary art
 
 **CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
 
-## 1. Verify Framework
+## 1. Stack Detection & Verify Framework
 
-Ensure a framework exists:
+**Read `config.test_stack_type`** from `{config_source}`.
+
+**Auto-Detection Algorithm** (when `test_stack_type` is `"auto"` or not configured):
+
+- Scan `{project-root}` for project manifests:
+  - **Frontend indicators**: `package.json` with react/vue/angular/next dependencies, `playwright.config.*`, `vite.config.*`, `webpack.config.*`
+  - **Backend indicators**: `pyproject.toml`, `pom.xml`/`build.gradle`, `go.mod`, `*.csproj`/`*.sln`, `Gemfile`, `Cargo.toml`
+  - **Both present** = `fullstack`; only frontend = `frontend`; only backend = `backend`
+- Explicit `test_stack_type` config value overrides auto-detection
+- **Backward compatibility**: if `test_stack_type` is not in config, treat as `"auto"` (preserves current frontend behavior for existing installs)
+
+Store result as `{detected_stack}` = `frontend` | `backend` | `fullstack`
+
+**Verify framework exists:**
+
+**If {detected_stack} is `frontend` or `fullstack`:**
 
 - `playwright.config.ts` or `cypress.config.ts`
 - `package.json` includes test dependencies
 
+**If {detected_stack} is `backend` or `fullstack`:**
+
+- Relevant test config exists (e.g., `conftest.py`, `src/test/`, `*_test.go`, `.rspec`, test project `*.csproj`)
+
 If missing: **HALT** with message "Run `framework` workflow first."
 
 ---
@@ -78,9 +97,32 @@ If missing: **HALT** with message "Run `framework` workflow first."
 
 - From `{config_source}` read `tea_use_playwright_utils`
 - From `{config_source}` read `tea_browser_automation`
+- From `{config_source}` read `test_stack_type`
 
 ---
 
+### Tiered Knowledge Loading
+
+Load fragments based on their `tier` classification in `tea-index.csv`:
+
+1. **Core tier** (always load): Foundational fragments required for this workflow
+2. **Extended tier** (load on-demand): Load when deeper analysis is needed or when the user's context requires it
+3. **Specialized tier** (load only when relevant): Load only when the specific use case matches (e.g., contract-testing only for microservices, email-auth only for email flows)
+
+> **Context Efficiency**: Loading only core fragments reduces context usage by 40-50% compared to loading all fragments.
+
+### Playwright Utils Loading Profiles
+
+**If `tea_use_playwright_utils` is enabled**, select the appropriate loading profile:
+
+- **API-only profile** (when `{detected_stack}` is `backend` or no `page.goto`/`page.locator` found in test files):
+  Load: `overview`, `api-request`, `auth-session`, `recurse` (~1,800 lines)
+
+- **Full UI+API profile** (when `{detected_stack}` is `frontend`/`fullstack` or browser tests detected):
+  Load: all Playwright Utils core fragments (~4,500 lines)
+
+**Detection**: Scan `{test_dir}` for files containing `page.goto` or `page.locator`. If none found, use API-only profile.
+
 ## 4. Load Knowledge Base Fragments
 
 Use `{knowledgeIndex}` and load only what is required.
@@ -147,6 +189,8 @@ Summarize loaded artifacts, framework, and knowledge fragments, then proceed.
   - Set `lastSaved: '{date}'`
   - Append this step's output to the appropriate section.
 
+**Update `inputDocuments`**: Set `inputDocuments` in the output template frontmatter to the list of artifact paths loaded in this step (e.g., knowledge fragments, test design documents, configuration files).
+
 Load next step: `{nextStepFile}`
 
 ## 🚨 SYSTEM SUCCESS/FAILURE METRICS:

package/src/workflows/testarch/automate/steps-c/step-02-identify-targets.md

@@ -50,6 +50,8 @@ Determine what needs to be tested and select appropriate test levels and priorit
 - Otherwise auto-discover features in `{source_dir}`
 - Prioritize critical paths, integrations, and untested logic
 
+**If {detected_stack} is `frontend` or `fullstack`:**
+
 **Browser Exploration (if `tea_browser_automation` is `cli` or `auto`):**
 
 > **Fallback:** If CLI is not installed, fall back to MCP (if available) or skip browser exploration and rely on code/doc analysis.
@@ -63,6 +65,16 @@ Use CLI to explore the application and identify testable pages/flows:
 
 > **Session Hygiene:** Always close sessions using `playwright-cli -s=tea-automate close`. Do NOT use `close-all` — it kills every session on the machine and breaks parallel execution.
 
+**If {detected_stack} is `backend` or `fullstack`:**
+
+**Source & API Analysis (no browser exploration):**
+
+- Scan source code for route handlers, controllers, service classes, and public APIs
+- Read OpenAPI/Swagger specs (`openapi.yaml`, `swagger.json`) if available
+- Identify database models, migrations, and data access patterns
+- Map service-to-service integrations and message queue consumers/producers
+- Check for existing contract tests (Pact, etc.)
+
 ---
 
 ## 2. Choose Test Levels

package/src/workflows/testarch/automate/steps-c/step-03-generate-tests.md

@@ -8,16 +8,16 @@ nextStepFile: './step-03c-aggregate.md'
 
 ## STEP GOAL
 
-Launch parallel subprocesses to generate API and E2E tests simultaneously for maximum performance.
+Launch parallel subprocesses to generate tests simultaneously for maximum performance. Subprocess selection depends on `{detected_stack}`.
 
 ## MANDATORY EXECUTION RULES
 
 - 📖 Read the entire step file before acting
 - ✅ Speak in `{communication_language}`
-- ✅ Launch TWO subprocesses in PARALLEL
-- ✅ Wait for BOTH subprocesses to complete
+- ✅ Launch subprocesses in PARALLEL based on `{detected_stack}`
+- ✅ Wait for ALL launched subprocesses to complete
 - ❌ Do NOT generate tests sequentially (use subprocesses)
-- ❌ Do NOT proceed until both subprocesses finish
+- ❌ Do NOT proceed until all subprocesses finish
 
 ---
 
@@ -48,7 +48,7 @@ Launch parallel subprocesses to generate API and E2E tests simultaneously for ma
 const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
 ```
 
-**Prepare input context for both subprocesses:**
+**Prepare input context for subprocesses:**
 
 ```javascript
 const subprocessContext = {
@@ -57,7 +57,8 @@ const subprocessContext = {
   config: {
     test_framework: config.test_framework,
     use_playwright_utils: config.tea_use_playwright_utils,
-    browser_automation: config.tea_browser_automation  // "auto" | "cli" | "mcp" | "none"
+    browser_automation: config.tea_browser_automation,  // "auto" | "cli" | "mcp" | "none"
+    detected_stack: '{detected_stack}'  // "frontend" | "backend" | "fullstack"
   },
   timestamp: timestamp
 };
@@ -65,7 +66,19 @@ const subprocessContext = {
 
 ---
 
-### 2. Launch Subprocess A: API Test Generation
+### 2. Subprocess Dispatch Matrix
+
+**Select subprocesses based on `{detected_stack}`:**
+
+| `{detected_stack}` | Subprocess A (API) | Subprocess B (E2E) | Subprocess B-backend |
+| ------------------ | ------------------ | ------------------ | -------------------- |
+| `frontend`         | Launch             | Launch             | Skip                 |
+| `backend`          | Launch             | Skip               | Launch               |
+| `fullstack`        | Launch             | Launch             | Launch               |
+
+---
+
+### 3. Launch Subprocess A: API Test Generation (always)
 
 **Launch subprocess in parallel:**
 
@@ -84,7 +97,9 @@ const subprocessContext = {
 
 ---
 
-### 3. Launch Subprocess B: E2E Test Generation
+### 4. Launch Subprocess B: E2E Test Generation (frontend/fullstack only)
+
+**If {detected_stack} is `frontend` or `fullstack`:**
 
 **Launch subprocess in parallel:**
 
@@ -101,62 +116,125 @@ const subprocessContext = {
 ⏳ Status: Running in parallel...
 ```
 
+**If {detected_stack} is `backend`:** Skip this subprocess.
+
 ---
 
-### 4. Wait for Both Subprocesses to Complete
+### 5. Launch Subprocess B-backend: Backend Test Generation (backend/fullstack only)
+
+**If {detected_stack} is `backend` or `fullstack`:**
 
-**Monitor subprocess execution:**
+**Launch subprocess in parallel:**
+
+- **Subprocess File:** `./step-03b-subprocess-backend.md`
+- **Output File:** `/tmp/tea-automate-backend-tests-${timestamp}.json`
+- **Context:** Pass `subprocessContext`
+- **Execution:** PARALLEL (non-blocking)
+
+**System Action:**
+
+```
+🚀 Launching Subprocess B-backend: Backend Test Generation
+📝 Output: /tmp/tea-automate-backend-tests-${timestamp}.json
+⏳ Status: Running in parallel...
+```
+
+**If {detected_stack} is `frontend`:** Skip this subprocess.
+
+---
+
+### 6. Wait for All Subprocesses to Complete
+
+**Monitor subprocess execution based on `{detected_stack}`:**
 
 ```
 ⏳ Waiting for subprocesses to complete...
   ├── Subprocess A (API): Running... ⟳
-  └── Subprocess B (E2E): Running... ⟳
+  ├── Subprocess B (E2E): Running... ⟳       [if frontend/fullstack]
+  └── Subprocess B-backend: Running... ⟳     [if backend/fullstack]
 
 [... time passes ...]
 
   ├── Subprocess A (API): Complete ✅
-  └── Subprocess B (E2E): Complete ✅
+  ├── Subprocess B (E2E): Complete ✅         [if frontend/fullstack]
+  └── Subprocess B-backend: Complete ✅       [if backend/fullstack]
 
 ✅ All subprocesses completed successfully!
 ```
 
-**Verify both outputs exist:**
+**Verify outputs exist (based on `{detected_stack}`):**
 
 ```javascript
 const apiOutputExists = fs.existsSync(`/tmp/tea-automate-api-tests-${timestamp}.json`);
-const e2eOutputExists = fs.existsSync(`/tmp/tea-automate-e2e-tests-${timestamp}.json`);
 
-if (!apiOutputExists || !e2eOutputExists) {
-  throw new Error('One or both subprocess outputs missing!');
+// Check based on detected_stack
+if (detected_stack === 'frontend' || detected_stack === 'fullstack') {
+  const e2eOutputExists = fs.existsSync(`/tmp/tea-automate-e2e-tests-${timestamp}.json`);
+  if (!e2eOutputExists) throw new Error('E2E subprocess output missing!');
+}
+if (detected_stack === 'backend' || detected_stack === 'fullstack') {
+  const backendOutputExists = fs.existsSync(`/tmp/tea-automate-backend-tests-${timestamp}.json`);
+  if (!backendOutputExists) throw new Error('Backend subprocess output missing!');
 }
+if (!apiOutputExists) throw new Error('API subprocess output missing!');
 ```
 
 ---
 
-### 5. Performance Report
+### Subprocess Output Schema Contract
+
+Both `step-03b-subprocess-e2e.md` and `step-03b-subprocess-backend.md` MUST write JSON to their output file with identical schema:
+
+```json
+{
+  "subprocessType": "e2e | backend",
+  "testsGenerated": [
+    {
+      "file": "path/to/test-file",
+      "content": "[full test file content]",
+      "description": "Test description",
+      "priority_coverage": { "P0": 0, "P1": 0, "P2": 0, "P3": 0 }
+    }
+  ],
+  "coverageSummary": {
+    "totalTests": 0,
+    "testLevels": ["unit", "integration", "api", "e2e"],
+    "fixtureNeeds": []
+  },
+  "status": "complete | partial"
+}
+```
+
+The aggregate step reads whichever output file(s) exist based on `{detected_stack}`.
+
+---
+
+### 7. Performance Report
 
 **Display performance metrics:**
 
 ```
 🚀 Performance Report:
-- Execution Mode: PARALLEL (2 subprocesses)
+- Execution Mode: PARALLEL (subprocesses based on {detected_stack})
+- Stack Type: {detected_stack}
 - API Test Generation: ~X minutes
-- E2E Test Generation: ~Y minutes
-- Total Elapsed: ~max(X, Y) minutes
-- Sequential Would Take: ~(X + Y) minutes
-- Performance Gain: ~50% faster!
+- E2E Test Generation: ~Y minutes       [if frontend/fullstack]
+- Backend Test Generation: ~Z minutes    [if backend/fullstack]
+- Total Elapsed: ~max(X, Y, Z) minutes
+- Sequential Would Take: ~(X + Y + Z) minutes
+- Performance Gain: ~40-70% faster!
 ```
 
 ---
 
-### 6. Proceed to Aggregation
+### 8. Proceed to Aggregation
 
 **Load aggregation step:**
 Load next step: `{nextStepFile}`
 
 The aggregation step (3C) will:
 
-- Read both subprocess outputs
+- Read all subprocess outputs (based on `{detected_stack}`)
 - Write all test files to disk
 - Generate shared fixtures and helpers
 - Calculate summary statistics
@@ -168,13 +246,14 @@ The aggregation step (3C) will:
 Proceed to Step 3C (Aggregation) when:
 
 - ✅ Subprocess A (API tests) completed successfully
-- ✅ Subprocess B (E2E tests) completed successfully
-- ✅ Both output files exist and are valid JSON
+- ✅ Subprocess B (E2E tests) completed successfully [if frontend/fullstack]
+- ✅ Subprocess B-backend (Backend tests) completed successfully [if backend/fullstack]
+- ✅ All expected output files exist and are valid JSON
 - ✅ Performance metrics displayed
 
 **Do NOT proceed if:**
 
-- ❌ One or both subprocesses failed
+- ❌ Any launched subprocess failed
 - ❌ Output files missing or corrupted
 - ❌ Timeout occurred (subprocesses took too long)
 
@@ -184,15 +263,15 @@ Proceed to Step 3C (Aggregation) when:
 
 ### ✅ SUCCESS:
 
-- Both subprocesses launched successfully
-- Both subprocesses completed without errors
+- All required subprocesses launched successfully (based on `{detected_stack}`)
+- All subprocesses completed without errors
 - Output files generated and valid
-- Parallel execution achieved ~50% performance gain
+- Parallel execution achieved ~40-70% performance gain
 
 ### ❌ SYSTEM FAILURE:
 
 - Failed to launch subprocesses
-- One or both subprocesses failed
+- One or more subprocesses failed
 - Output files missing or invalid
 - Attempted sequential generation instead of parallel