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

package/src/workflows/testarch/automate/steps-c/step-03b-subprocess-backend.md

@@ -0,0 +1,246 @@
+---
+name: 'step-03b-subprocess-backend'
+description: 'Subprocess: Generate backend tests only (unit, integration, contract)'
+subprocess: true
+outputFile: '/tmp/tea-automate-backend-tests-{{timestamp}}.json'
+---
+
+# Subprocess 3B-backend: Generate Backend Tests
+
+## SUBPROCESS CONTEXT
+
+This is an **isolated subprocess** running in parallel with API test generation (and optionally E2E test generation for fullstack projects).
+
+**What you have from parent workflow:**
+
+- Target features/services identified in Step 2
+- Knowledge fragments loaded: test-levels-framework, test-priorities-matrix, data-factories
+- Config: test framework, detected stack type
+- Coverage plan: which services/modules need backend testing
+
+**Your task:** Generate backend tests ONLY (unit, integration, contract - not API endpoint tests, not E2E).
+
+---
+
+## MANDATORY EXECUTION RULES
+
+- Read this entire subprocess file before acting
+- Generate backend tests ONLY (unit, integration, contract)
+- Output structured JSON to temp file using the subprocess output schema contract
+- Follow knowledge fragment patterns
+- Do NOT generate API endpoint tests (that's subprocess 3A)
+- Do NOT generate E2E tests (that's subprocess 3B)
+- Do NOT run tests (that's step 4)
+- Do NOT generate fixtures yet (that's step 3C aggregation)
+
+---
+
+## SUBPROCESS TASK
+
+### 1. Identify Test Targets
+
+From the coverage plan (Step 2 output), identify:
+
+- Which services/modules need unit test coverage
+- Which integrations need integration test coverage (database, message queues, external services)
+- Which service contracts need contract test coverage (Pact, schema validation)
+- Business logic functions requiring edge case coverage
+
+### 2. Detect Framework & Language
+
+From `config.test_framework` and project manifests, determine:
+
+- **Python (pytest)**: Use `pytest` conventions, `conftest.py` fixtures, `@pytest.mark` decorators
+- **Java/Kotlin (JUnit)**: Use JUnit 5 annotations (`@Test`, `@BeforeEach`, `@Nested`), Mockito for mocking
+- **Go (go test)**: Use `*_test.go` files, `testing.T`, table-driven tests, `testify` assertions
+- **C#/.NET (xUnit)**: Use `[Fact]`, `[Theory]`, `[InlineData]`, `Moq` for mocking
+- **Ruby (RSpec)**: Use `describe`/`context`/`it` blocks, `let`/`before` helpers, `FactoryBot`
+
+### 3. Generate Unit Tests
+
+For each module/service, create test files following language-idiomatic patterns:
+
+**Python (pytest) example:**
+
+```python
+import pytest
+from unittest.mock import MagicMock, patch
+from myapp.services.user_service import UserService
+
+class TestUserService:
+    """[P0] Unit tests for UserService"""
+
+    def test_create_user_with_valid_data(self, user_factory):
+        """Should create user when data is valid"""
+        user_data = user_factory.build()
+        result = UserService.create(user_data)
+        assert result.email == user_data["email"]
+
+    def test_create_user_rejects_duplicate_email(self, user_factory):
+        """[P1] Should reject duplicate email"""
+        user_data = user_factory.build(email="existing@test.com")
+        with pytest.raises(DuplicateEmailError):
+            UserService.create(user_data)
+```
+
+**Go (go test) example:**
+
+```go
+func TestUserService_Create(t *testing.T) {
+    tests := []struct {
+        name    string
+        input   CreateUserInput
+        wantErr bool
+    }{
+        {"valid user", validInput(), false},
+        {"duplicate email", duplicateInput(), true},
+    }
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            svc := NewUserService(mockRepo)
+            _, err := svc.Create(tt.input)
+            if (err != nil) != tt.wantErr {
+                t.Errorf("Create() error = %v, wantErr %v", err, tt.wantErr)
+            }
+        })
+    }
+}
+```
+
+**Requirements:**
+
+- Follow the detected framework's idiomatic test patterns
+- Include priority tags [P0], [P1], [P2], [P3] in test descriptions
+- Use proper mocking for external dependencies (database, APIs, message queues)
+- Test both happy path and error cases
+- Use proper typing/type hints where applicable
+- No hard-coded test data; use factories or builders
+
+### 4. Generate Integration Tests
+
+For service integrations, create integration test files:
+
+- Database integration tests (with test database or in-memory alternatives)
+- Message queue consumer/producer tests
+- Cache integration tests
+- External service integration tests (with mocked HTTP clients)
+
+### 5. Generate Contract Tests (if applicable)
+
+If the project uses microservices or has defined API contracts:
+
+- Pact consumer/provider tests
+- Schema validation tests (JSON Schema, Protobuf)
+- OpenAPI spec compliance tests
+
+### 6. Track Fixture Needs
+
+Identify fixtures/helpers needed for backend tests:
+
+- Database fixtures (seed data, cleanup)
+- Factory functions (test data builders)
+- Mock services (HTTP mocks, message queue mocks)
+- Configuration fixtures (test environment config)
+
+**Do NOT create fixtures yet** - just track what's needed for aggregation step.
+
+---
+
+## OUTPUT FORMAT
+
+Write JSON to temp file: `/tmp/tea-automate-backend-tests-{{timestamp}}.json`
+
+```json
+{
+  "subprocessType": "backend",
+  "testsGenerated": [
+    {
+      "file": "tests/unit/test_user_service.py",
+      "content": "[full test file content]",
+      "description": "Unit tests for UserService",
+      "priority_coverage": {
+        "P0": 3,
+        "P1": 2,
+        "P2": 1,
+        "P3": 0
+      }
+    },
+    {
+      "file": "tests/integration/test_user_repository.py",
+      "content": "[full test file content]",
+      "description": "Integration tests for user database operations",
+      "priority_coverage": {
+        "P0": 1,
+        "P1": 2,
+        "P2": 1,
+        "P3": 0
+      }
+    }
+  ],
+  "coverageSummary": {
+    "totalTests": 15,
+    "testLevels": ["unit", "integration", "contract"],
+    "fixtureNeeds": ["databaseFixture", "userFactory", "mockHttpClient"]
+  },
+  "status": "complete",
+  "success": true,
+  "subprocess": "backend-tests",
+  "knowledge_fragments_used": ["test-levels-framework", "test-priorities-matrix", "data-factories"],
+  "summary": "Generated 15 backend test cases (10 unit, 4 integration, 1 contract)"
+}
+```
+
+**On Error:**
+
+```json
+{
+  "subprocessType": "backend",
+  "testsGenerated": [],
+  "coverageSummary": {
+    "totalTests": 0,
+    "testLevels": [],
+    "fixtureNeeds": []
+  },
+  "status": "partial",
+  "success": false,
+  "subprocess": "backend-tests",
+  "error": "Error message describing what went wrong",
+  "partial_output": {
+    /* any tests generated before error */
+  }
+}
+```
+
+---
+
+## EXIT CONDITION
+
+Subprocess completes when:
+
+- All identified modules have backend test files generated
+- All tests follow language-idiomatic patterns
+- JSON output written to temp file using the subprocess output schema contract
+- Fixture needs tracked
+
+**Subprocess terminates here.** Parent workflow will read output and proceed to aggregation.
+
+---
+
+## SUBPROCESS SUCCESS METRICS
+
+### SUCCESS:
+
+- All backend tests generated following idiomatic patterns
+- JSON output valid and complete, matches subprocess output schema contract
+- No E2E or browser tests included (out of scope)
+- Proper mocking used for external dependencies
+- Priority tags assigned to all test cases
+
+### FAILURE:
+
+- Generated tests other than backend tests (unit/integration/contract)
+- Did not follow language-idiomatic patterns
+- Invalid or missing JSON output
+- Output schema does not match the contract
+- Ran tests (not subprocess responsibility)
+- Used real external services instead of mocks

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

@@ -9,7 +9,7 @@ nextStepFile: './step-04-validate-and-summarize.md'
 
 ## STEP GOAL
 
-Read outputs from parallel subprocesses (API + E2E test generation), aggregate results, and create supporting infrastructure (fixtures, helpers).
+Read outputs from parallel subprocesses (API + E2E and/or Backend test generation based on `{detected_stack}`), aggregate results, and create supporting infrastructure (fixtures, helpers).
 
 ---
 
@@ -46,25 +46,39 @@ Read outputs from parallel subprocesses (API + E2E test generation), aggregate r
 
 ### 1. Read Subprocess Outputs
 
-**Read API test subprocess output:**
+**Read API test subprocess output (always):**
 
 ```javascript
 const apiTestsPath = '/tmp/tea-automate-api-tests-{{timestamp}}.json';
 const apiTestsOutput = JSON.parse(fs.readFileSync(apiTestsPath, 'utf8'));
 ```
 
-**Read E2E test subprocess output:**
+**Read E2E test subprocess output (if {detected_stack} is `frontend` or `fullstack`):**
 
 ```javascript
-const e2eTestsPath = '/tmp/tea-automate-e2e-tests-{{timestamp}}.json';
-const e2eTestsOutput = JSON.parse(fs.readFileSync(e2eTestsPath, 'utf8'));
+let e2eTestsOutput = null;
+if (detected_stack === 'frontend' || detected_stack === 'fullstack') {
+  const e2eTestsPath = '/tmp/tea-automate-e2e-tests-{{timestamp}}.json';
+  e2eTestsOutput = JSON.parse(fs.readFileSync(e2eTestsPath, 'utf8'));
+}
 ```
 
-**Verify both subprocesses succeeded:**
+**Read Backend test subprocess output (if {detected_stack} is `backend` or `fullstack`):**
+
+```javascript
+let backendTestsOutput = null;
+if (detected_stack === 'backend' || detected_stack === 'fullstack') {
+  const backendTestsPath = '/tmp/tea-automate-backend-tests-{{timestamp}}.json';
+  backendTestsOutput = JSON.parse(fs.readFileSync(backendTestsPath, 'utf8'));
+}
+```
+
+**Verify all launched subprocesses succeeded:**
 
 - Check `apiTestsOutput.success === true`
-- Check `e2eTestsOutput.success === true`
-- If either failed, report error and stop (don't proceed)
+- If E2E was launched: check `e2eTestsOutput.success === true`
+- If Backend was launched: check `backendTestsOutput.success === true`
+- If any failed, report error and stop (don't proceed)
 
 ---
 
@@ -79,23 +93,40 @@ apiTestsOutput.tests.forEach((test) => {
 });
 ```
 
-**Write E2E test files:**
+**Write E2E test files (if {detected_stack} is `frontend` or `fullstack`):**
 
 ```javascript
-e2eTestsOutput.tests.forEach((test) => {
-  fs.writeFileSync(test.file, test.content, 'utf8');
-  console.log(`✅ Created: ${test.file}`);
-});
+if (e2eTestsOutput) {
+  e2eTestsOutput.tests.forEach((test) => {
+    fs.writeFileSync(test.file, test.content, 'utf8');
+    console.log(`✅ Created: ${test.file}`);
+  });
+}
+```
+
+**Write Backend test files (if {detected_stack} is `backend` or `fullstack`):**
+
+```javascript
+if (backendTestsOutput) {
+  backendTestsOutput.testsGenerated.forEach((test) => {
+    fs.writeFileSync(test.file, test.content, 'utf8');
+    console.log(`✅ Created: ${test.file}`);
+  });
+}
 ```
 
 ---
 
 ### 3. Aggregate Fixture Needs
 
-**Collect all fixture needs from both subprocesses:**
+**Collect all fixture needs from all launched subprocesses:**
 
 ```javascript
-const allFixtureNeeds = [...apiTestsOutput.fixture_needs, ...e2eTestsOutput.fixture_needs];
+const allFixtureNeeds = [
+  ...apiTestsOutput.fixture_needs,
+  ...(e2eTestsOutput ? e2eTestsOutput.fixture_needs : []),
+  ...(backendTestsOutput ? backendTestsOutput.coverageSummary?.fixtureNeeds || [] : []),
+];
 
 // Remove duplicates
 const uniqueFixtures = [...new Set(allFixtureNeeds)];
@@ -190,28 +221,47 @@ export const waitForApiResponse = async (page: Page, urlPattern: string) => {
 
 ### 5. Calculate Summary Statistics
 
-**Aggregate test counts:**
+**Aggregate test counts (based on `{detected_stack}`):**
 
 ```javascript
+const e2eCount = e2eTestsOutput ? e2eTestsOutput.test_count : 0;
+const backendCount = backendTestsOutput ? (backendTestsOutput.coverageSummary?.totalTests ?? 0) : 0;
+
 const summary = {
-  total_tests: apiTestsOutput.test_count + e2eTestsOutput.test_count,
+  detected_stack: '{detected_stack}',
+  total_tests: apiTestsOutput.test_count + e2eCount + backendCount,
   api_tests: apiTestsOutput.test_count,
-  e2e_tests: e2eTestsOutput.test_count,
+  e2e_tests: e2eCount,
+  backend_tests: backendCount,
   fixtures_created: uniqueFixtures.length,
   api_test_files: apiTestsOutput.tests.length,
-  e2e_test_files: e2eTestsOutput.tests.length,
+  e2e_test_files: e2eTestsOutput ? e2eTestsOutput.tests.length : 0,
+  backend_test_files: backendTestsOutput ? backendTestsOutput.testsGenerated.length : 0,
   priority_coverage: {
-    P0: /* sum P0 tests from both */,
-    P1: /* sum P1 tests from both */,
-    P2: /* sum P2 tests from both */,
-    P3: /* sum P3 tests from both */
+    P0:
+      (apiTestsOutput.priority_coverage?.P0 ?? 0) +
+      (e2eTestsOutput?.priority_coverage?.P0 ?? 0) +
+      (backendTestsOutput?.testsGenerated?.reduce((sum, t) => sum + (t.priority_coverage?.P0 ?? 0), 0) ?? 0),
+    P1:
+      (apiTestsOutput.priority_coverage?.P1 ?? 0) +
+      (e2eTestsOutput?.priority_coverage?.P1 ?? 0) +
+      (backendTestsOutput?.testsGenerated?.reduce((sum, t) => sum + (t.priority_coverage?.P1 ?? 0), 0) ?? 0),
+    P2:
+      (apiTestsOutput.priority_coverage?.P2 ?? 0) +
+      (e2eTestsOutput?.priority_coverage?.P2 ?? 0) +
+      (backendTestsOutput?.testsGenerated?.reduce((sum, t) => sum + (t.priority_coverage?.P2 ?? 0), 0) ?? 0),
+    P3:
+      (apiTestsOutput.priority_coverage?.P3 ?? 0) +
+      (e2eTestsOutput?.priority_coverage?.P3 ?? 0) +
+      (backendTestsOutput?.testsGenerated?.reduce((sum, t) => sum + (t.priority_coverage?.P3 ?? 0), 0) ?? 0),
   },
   knowledge_fragments_used: [
     ...apiTestsOutput.knowledge_fragments_used,
-    ...e2eTestsOutput.knowledge_fragments_used
+    ...(e2eTestsOutput ? e2eTestsOutput.knowledge_fragments_used : []),
+    ...(backendTestsOutput ? backendTestsOutput.knowledge_fragments_used || [] : []),
   ],
-  subprocess_execution: 'PARALLEL (API + E2E)',
-  performance_gain: '~50% faster than sequential'
+  subprocess_execution: `PARALLEL (based on ${detected_stack})`,
+  performance_gain: '~40-70% faster than sequential',
 };
 ```
 
@@ -230,7 +280,8 @@ fs.writeFileSync('/tmp/tea-automate-summary-{{timestamp}}.json', JSON.stringify(
 
 ```javascript
 fs.unlinkSync(apiTestsPath);
-fs.unlinkSync(e2eTestsPath);
+if (e2eTestsOutput) fs.unlinkSync('/tmp/tea-automate-e2e-tests-{{timestamp}}.json');
+if (backendTestsOutput) fs.unlinkSync('/tmp/tea-automate-backend-tests-{{timestamp}}.json');
 console.log('✅ Subprocess temp files cleaned up');
 ```
 
@@ -244,9 +295,11 @@ Display to user:
 ✅ Test Generation Complete (Parallel Execution)
 
 📊 Summary:
+- Stack Type: {detected_stack}
 - Total Tests: {total_tests}
   - API Tests: {api_tests} ({api_test_files} files)
-  - E2E Tests: {e2e_tests} ({e2e_test_files} files)
+  - E2E Tests: {e2e_tests} ({e2e_test_files} files)         [if frontend/fullstack]
+  - Backend Tests: {backend_tests} ({backend_test_files} files)  [if backend/fullstack]
 - Fixtures Created: {fixtures_created}
 - Priority Coverage:
   - P0 (Critical): {P0} tests
@@ -254,15 +307,14 @@ Display to user:
   - P2 (Medium): {P2} tests
   - P3 (Low): {P3} tests
 
-🚀 Performance: Parallel execution ~50% faster than sequential
+🚀 Performance: Parallel execution ~40-70% faster than sequential
 
 📂 Generated Files:
-- tests/api/[feature].spec.ts
-- tests/e2e/[feature].spec.ts
-- tests/fixtures/auth.ts
-- tests/fixtures/data-factories.ts
-- tests/fixtures/network-mocks.ts
-- tests/fixtures/helpers.ts
+- tests/api/[feature].spec.ts                                [always]
+- tests/e2e/[feature].spec.ts                                [if frontend/fullstack]
+- tests/unit/[feature].test.*                                 [if backend/fullstack]
+- tests/integration/[feature].test.*                          [if backend/fullstack]
+- tests/fixtures/ or tests/support/                           [shared infrastructure]
 
 ✅ Ready for validation (Step 4)
 ```
@@ -273,7 +325,7 @@ Display to user:
 
 Proceed to Step 4 when:
 
-- ✅ All test files written to disk (API + E2E)
+- ✅ All test files written to disk (API + E2E and/or Backend, based on `{detected_stack}`)
 - ✅ All fixtures and helpers created
 - ✅ Summary statistics calculated and saved
 - ✅ Output displayed to user
@@ -310,14 +362,14 @@ Load next step: `{nextStepFile}`
 
 ### ✅ SUCCESS:
 
-- Both subprocesses succeeded
+- All launched subprocesses succeeded (based on `{detected_stack}`)
 - All test files written to disk
 - Fixtures generated based on subprocess needs
 - Summary complete and accurate
 
 ### ❌ SYSTEM FAILURE:
 
-- One or both subprocesses failed
+- One or more subprocesses failed
 - Test files not written to disk
 - Fixtures missing or incomplete
 - Summary missing or inaccurate

package/src/workflows/testarch/automate/steps-c/step-04-validate-and-summarize.md

@@ -50,7 +50,18 @@ Fix gaps before proceeding.
 
 ---
 
-## 2. Summary Output
+## 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. Summary Output
 
 Write `{outputFile}` including:
 
@@ -61,7 +72,7 @@ Write `{outputFile}` including:
 
 ---
 
-## 3. Save Progress
+## 4. Save Progress
 
 **Save this step's accumulated work to `{outputFile}`.**
 

package/src/workflows/testarch/ci/azure-pipelines-template.yaml

@@ -0,0 +1,155 @@
+# Azure DevOps CI/CD Pipeline for Test Execution
+# Generated by BMad TEA Agent - Test Architect Module
+# Optimized for: Parallel Sharding, Burn-In Loop
+# Stack: {test_stack_type} | Framework: {test_framework}
+#
+# Variables to customize per project:
+#   INSTALL_CMD       - dependency install command (e.g., npm ci, pnpm install --frozen-lockfile)
+#   TEST_CMD          - main test command (e.g., npm run test:e2e, npm test, npx vitest)
+#   LINT_CMD          - lint command (e.g., npm run lint)
+#   BROWSER_INSTALL   - browser install command (frontend/fullstack only; omit for backend)
+#   DEFAULT_NODE_VERSION - Node.js version (read from .nvmrc or default to 24)
+
+trigger:
+  branches:
+    include:
+      - main
+      - develop
+
+pr:
+  branches:
+    include:
+      - main
+      - develop
+
+variables:
+  DEFAULT_NODE_VERSION: "24"
+  npm_config_cache: $(Pipeline.Workspace)/.npm
+  # Set TEST_STACK_TYPE to 'backend' to skip Playwright browser installs
+  TEST_STACK_TYPE: "" # Values: frontend, backend, fullstack (leave empty for auto)
+
+stages:
+  # Lint stage - Code quality checks
+  - stage: Lint
+    displayName: "Lint"
+    jobs:
+      - job: LintJob
+        displayName: "Code Quality"
+        pool:
+          vmImage: "ubuntu-latest"
+        timeoutInMinutes: 5
+        steps:
+          - task: NodeTool@0
+            inputs:
+              versionSpec: $(DEFAULT_NODE_VERSION)
+            displayName: "Setup Node.js"
+
+          - task: Cache@2
+            inputs:
+              key: 'npm | "$(Agent.OS)" | package-lock.json'
+              restoreKeys: 'npm | "$(Agent.OS)"'
+              path: $(npm_config_cache)
+            displayName: "Cache npm"
+
+          - script: npm ci
+            displayName: "Install dependencies" # Replace with INSTALL_CMD
+
+          - script: npm run lint
+            displayName: "Run linter" # Replace with LINT_CMD
+
+  # Test stage - Parallel execution with sharding
+  - stage: Test
+    displayName: "Test"
+    dependsOn: Lint
+    jobs:
+      - job: TestShard
+        displayName: "Test Shard"
+        pool:
+          vmImage: "ubuntu-latest"
+        timeoutInMinutes: 30
+        strategy:
+          matrix:
+            Shard1:
+              SHARD_INDEX: 1
+            Shard2:
+              SHARD_INDEX: 2
+            Shard3:
+              SHARD_INDEX: 3
+            Shard4:
+              SHARD_INDEX: 4
+        steps:
+          - task: NodeTool@0
+            inputs:
+              versionSpec: $(DEFAULT_NODE_VERSION)
+            displayName: "Setup Node.js"
+
+          - task: Cache@2
+            inputs:
+              key: 'npm | "$(Agent.OS)" | package-lock.json'
+              restoreKeys: 'npm | "$(Agent.OS)"'
+              path: $(npm_config_cache)
+            displayName: "Cache npm"
+
+          - script: npm ci
+            displayName: "Install dependencies" # Replace with INSTALL_CMD
+
+          # Frontend/Fullstack only — skipped for backend-only stacks
+          - script: npx playwright install --with-deps chromium
+            condition: ne(variables['TEST_STACK_TYPE'], 'backend')
+            displayName: "Install Playwright browsers" # Replace with BROWSER_INSTALL
+
+          - script: npm run test:e2e -- --shard=$(SHARD_INDEX)/4
+            displayName: "Run tests (shard $(SHARD_INDEX)/4)" # Replace with TEST_CMD + shard args
+
+          - task: PublishTestResults@2
+            condition: always()
+            inputs:
+              testResultsFormat: "JUnit"
+              testResultsFiles: "test-results/**/*.xml"
+              mergeTestResults: true
+            displayName: "Publish test results"
+
+          - publish: test-results/
+            artifact: test-results-$(SHARD_INDEX)
+            condition: failed()
+            displayName: "Upload failure artifacts"
+
+  # Burn-in stage - Flaky test detection
+  # Note: Burn-in targets UI flakiness. For backend-only stacks, remove this stage entirely.
+  - stage: BurnIn
+    displayName: "Burn-In (Flaky Detection)"
+    dependsOn: Test
+    condition: and(succeeded(), or(eq(variables['Build.Reason'], 'PullRequest'), eq(variables['Build.CronSchedule.DisplayName'], 'Weekly burn-in')))
+    jobs:
+      - job: BurnInJob
+        displayName: "Burn-In Loop"
+        pool:
+          vmImage: "ubuntu-latest"
+        timeoutInMinutes: 60
+        steps:
+          - task: NodeTool@0
+            inputs:
+              versionSpec: $(DEFAULT_NODE_VERSION)
+            displayName: "Setup Node.js"
+
+          - script: npm ci
+            displayName: "Install dependencies" # Replace with INSTALL_CMD
+
+          # Frontend/Fullstack only — skipped for backend-only stacks
+          - script: npx playwright install --with-deps chromium
+            condition: ne(variables['TEST_STACK_TYPE'], 'backend')
+            displayName: "Install Playwright browsers" # Replace with BROWSER_INSTALL
+
+          - script: |
+              echo "Starting burn-in loop - detecting flaky tests"
+              for i in $(seq 1 10); do
+                echo "Burn-in iteration $i/10"
+                npm run test:e2e || exit 1
+              done
+              echo "Burn-in complete - no flaky tests detected"
+            displayName: "Run burn-in loop (10 iterations)" # Replace npm run test:e2e with TEST_CMD
+
+          - publish: test-results/
+            artifact: burn-in-failures
+            condition: failed()
+            displayName: "Upload burn-in failure artifacts"