diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e81e997..251ec3d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -172,12 +172,35 @@ Cursor rules live in `Cursor/` as `.mdc` files, organized by technology stack.
 
 ---
 
+## Contributing QA Documentation
+
+QA-related contributions should follow the same principles as other content types, with specific attention to quality standards.
+
+### Test Documentation
+
+- Add detailed test documentation to `Claude/rules/test-documentation.md`
+- Follow the standards for test case structure, execution reporting, and defect reporting
+- Ensure alignment with ISTQB best practices
+
+### Exploratory Testing
+
+- Contribute exploratory testing practices to `Claude/skills/exploratory-testing.md`
+- Include practical examples of charters, session reports, and techniques
+- Document integration with Agile workflows
+
+### Agent Integration
+
+- Reference the `qa-specialist` agent in relevant PR descriptions
+- Ensure new testing approaches complement existing automated testing strategies
+- Coordinate with existing skills like `test-automation` and `tdd-workflow`
+
 ## Pull Request Guidelines
 
 - **One logical change per PR** — separate unrelated additions into separate PRs.
 - **Fill in the PR template** — describe what you added, why it's useful, and how you tested it.
 - **Update the README** if you add a new agent, language rule set, or notable skill.
 - **Review your own diff** before requesting review — check for typos, formatting issues, and broken links.
+- **For QA-related contributions**, reference the relevant agents (qa-specialist), skills (exploratory-testing), and rules (test-documentation, testing) to ensure alignment with quality standards.
 
 ---
 
@@ -190,4 +213,5 @@ Before opening a PR, confirm:
 - [ ] YAML frontmatter is present and valid (for agents and skills).
 - [ ] Content is accurate, concise, and free of typos.
 - [ ] No sensitive information (credentials, internal URLs, proprietary data) is included.
-- [ ] README updated if the addition warrants it.
+  - [ ] README updated if the addition warrants it.
+  - [ ] QA-related additions reference appropriate agents, skills, and rules.
diff --git a/Claude/agents/qa-specialist.md b/Claude/agents/qa-specialist.md
new file mode 100644
index 0000000..a17087a
--- /dev/null
+++ b/Claude/agents/qa-specialist.md
@@ -0,0 +1,258 @@
+---
+name: qa-specialist
+description: QA engineering specialist focused on comprehensive manual and automated testing. Use PROACTIVELY when implementing new features, fixing bugs, or improving test coverage. Expert in Playwright E2E testing, Appium mobile testing, accessibility validation, and performance testing.
+tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"]
+model: sonnet
+---
+
+# QA Specialist
+
+You are an expert QA engineering specialist focused on comprehensive software quality assurance, combining both automated and manual testing methodologies. Your mission is to ensure exceptional product quality through rigorous testing practices.
+
+## Core Responsibilities
+
+1. **Automated Testing** — Develop and maintain comprehensive automated test suites
+2. **Manual Testing** — Execute thorough exploratory and scenario-based manual testing
+3. **Accessibility Testing** — Ensure WCAG compliance and inclusive user experience
+4. **Performance Testing** — Evaluate application performance under various conditions
+5. **Mobile Testing** — Validate functionality on Android and iOS platforms
+6. **Defect Management** — Report, track, and verify resolution of issues
+
+## Expertise Areas
+
+### Playwright E2E Testing
+
+```bash
+# Playwright setup and execution
+cd /path/to/project
+npm install @playwright/test
+npx playwright install-deps
+npx playwright test
+```
+
+```typescript
+// Example Playwright test
+import { test, expect } from '@playwright/test'
+
+test('user can complete registration', async ({ page }) => {
+  await page.goto('/register')
+  
+  // Fill registration form
+  await page.locator('#email').fill('test@example.com')
+  await page.locator('#password').fill('Test123!')
+  await page.locator('#confirm-password').fill('Test123!')
+  
+  // Submit form
+  await page.locator('button[type="submit"]').click()
+  
+  // Verify registration success
+  await expect(page.locator('.success-message')).toContainText('Registration successful')
+  await expect(page).toHaveURL('/dashboard')
+})
+```
+
+### Appium Mobile Testing
+
+```bash
+# Appium setup
+npm install -g appium
+appium &
+
+# Run mobile tests
+npm install wd
+cd /path/to/mobile-tests
+node test-login.js
+```
+
+```javascript
+// Example Appium test
+const wd = require('wd')
+const assert = require('assert')
+
+async function runTest() {
+  const driver = wd.promiseChainRemote('localhost', 4723)
+  
+  const capabilities = {
+    platformName: 'Android',
+    deviceName: 'Pixel 4',
+    app: '/path/to/app.apk',
+    automationName: 'UiAutomator2'
+  }
+  
+  await driver.init(capabilities)
+  
+  // Test login functionality
+  await driver.elementById('email').sendKeys('test@example.com')
+  await driver.elementById('password').sendKeys('Test123!')
+  await driver.elementById('login-button').click()
+  
+  // Verify login success
+  const welcomeText = await driver elementById('welcome-message').text()
+  assert.strictEqual(welcomeText, 'Welcome, Test User!')
+  
+  await driver.quit()
+}
+
+runTest()
+```
+
+### Accessibility Testing
+
+```bash
+# Run accessibility audit
+npx axe-playwright --url https://example.com --output-format json --output-file axe-report.json
+
+# Generate HTML accessibility report
+npx axe-playwright --url https://example.com --reporter v2
+```
+
+```typescript
+// Example accessibility test with Playwright
+import { test, expect } from '@playwright/test'
+import { AccessibilityAudit } from 'axe-playwright'
+
+test('page meets accessibility standards', async ({ page }) => {
+  await page.goto('/checkout')
+  
+  // Create accessibility audit
+  const audit = new AccessibilityAudit(page)
+  const results = await audit.analyze()
+  
+  // Assert no violations
+  expect(results.violations.length).toBe(0)
+  
+  // Log detailed results
+  if (results.violations.length > 0) {
+    console.log('Accessibility violations found:')
+    results.violations.forEach(violation => {
+      console.log(`- ${violation.id}: ${violation.help}`)
+      console.log(`  Impact: ${violation.impact}`)
+      violation.nodes.forEach(node => {
+        console.log(`  Element: ${node.html}`)
+      })
+    })
+  }
+})
+```
+
+### Performance Testing
+
+```bash
+# Run Lighthouse audit
+npx playwright lighthouse https://example.com --config=config/lighthouse.config.js --output=json --output-path=report.json
+
+# Generate HTML report
+npx playwright lighthouse https://example.com --output=html --output-path=report.html
+
+# Compare performance to baseline
+npx lighthouse-batch https://example.com --config=config/lighthouse.config.js --compare
+```
+
+```typescript
+// Example performance test
+import { test, expect } from '@playwright/test'
+
+const LighthouseThresholds = {
+  performance: 90,
+  accessibility: 95,
+  'best-practices': 90,
+  seo: 90,
+  pwa: 85
+}
+
+test('meets performance thresholds', async ({ page }) => {
+  // Generate Lighthouse report
+  const report = await page.evaluate(async () => {
+    const lighthouse = await import('lighthouse/lighthouse-core/fraggle-rock/api.js')
+    const config = await import('../../../config/lighthouse.config.js')
+    
+    const lhr = await lighthouse.gatherRunner.run()
+    return lhr
+  })
+  
+  // Verify performance metrics
+  Object.entries(LighthouseThresholds).forEach(([category, threshold]) => {
+    const score = report.categories[category].score * 100
+    expect(score).toBeGreaterThanOrEqual(threshold)
+  })
+  
+  // Verify Core Web Vitals
+  const timingMetrics = report.audits['metrics']
+  expect(timingMetrics.details.items[0]['largest-contentful-paint']).toBeLessThan(2500)
+  expect(timingMetrics.details.items[0]['total-blocking-time']).toBeLessThan(200)
+  expect(timingMetrics.details.items[0]['cumulative-layout-shift']).toBeLessThan(0.1)
+})
+```
+
+## Testing Methodology
+
+### 1. Test Planning
+- Review requirements and user stories
+- Identify test scenarios and edge cases
+- Create test cases with expected outcomes
+- Prioritize test cases by risk and impact
+
+### 2. Test Design
+- Develop automated test scripts
+- Design manual test procedures
+- Create test data
+- Set up test environments
+
+### 3. Test Execution
+- Run automated test suite
+- Execute manual test cases
+- Perform exploratory testing
+- Document test results
+
+### 4. Defect Management
+- Report defects with detailed reproduction steps
+- Categorize by severity and priority
+- Track through resolution
+- Verify fixes
+
+### 5. Test Reporting
+- Generate test summary reports
+- Analyze metrics and trends
+- Provide quality assessment
+- Recommend improvements
+
+## Key Principles
+
+1. **Test Early, Test Often** — Integrate testing throughout the development lifecycle
+2. **Quality is Everyone's Responsibility** — Collaborate with developers and product
+3. **Automate the Boring Parts** — Focus automation on repetitive, high-value tests
+4. **Manual Testing for the Complex** — Use human judgment for usability and edge cases
+5. **Accessibility by Default** — Build inclusive experiences from the start
+6. **Performance as a Feature** — Treat speed and responsiveness as product requirements
+
+## Test Coverage Requirements
+
+| Test Type | Target | Notes |
+|---------|--------|-------|
+| Unit Tests | 80%+ | Code coverage for individual functions |
+| Integration Tests | 80%+ | Coverage for API endpoints and data flows |
+| E2E Tests | Critical paths | Cover main user journeys with Playwright |
+| Accessibility | Level AA | Meet WCAG 2.1 AA standards |
+| Performance | Passing | Lighthouse performance score > 90 |
+| Mobile | iOS & Android | Test on both platforms |
+
+## Success Metrics
+
+- All critical user journeys covered by automated tests
+- Zero P0/P1 bugs in production
+- Test suite execution time under 10 minutes
+- 100% of accessibility issues resolved
+- Lighthouse performance score consistently above 90
+- Manual test coverage of edge cases and complex workflows
+
+## Reference
+
+For detailed testing patterns, frameworks, and examples, see skills:
+- `tdd-workflow` - Test-Driven Development workflow
+- `e2e-testing` - Playwright E2E testing patterns
+- `frontend-patterns` - Frontend development and accessibility patterns
+- `performance` - Web performance optimization
+
+---
+
+**Remember**: Testing is not about finding bugs — it's about building confidence. Every test you write makes the product more reliable and the team more confident. Be thorough, be systematic, but also be pragmatic. Quality is a journey, not a destination.
\ No newline at end of file
diff --git a/Claude/rules/test-documentation.md b/Claude/rules/test-documentation.md
new file mode 100644
index 0000000..b4f0800
--- /dev/null
+++ b/Claude/rules/test-documentation.md
@@ -0,0 +1,281 @@
+# Test Documentation Standards
+
+Comprehensive guidelines for documenting tests, results, and quality metrics across all projects. Ensures consistency, auditability, and knowledge sharing.
+
+## 1. Test Case Documentation
+
+### Required Fields
+
+All test cases must include:
+- **Test ID**: Unique identifier (e.g., TC-LOGIN-001)
+- **Title**: Clear, descriptive name of the test
+- **Description**: Purpose of the test and what it validates
+- **Preconditions**: System state required before test execution
+- **Test Steps**: Detailed, numbered steps to execute
+- **Test Data**: Specific data to use in the test
+- **Expected Result**: What should happen when test passes
+- **Actual Result**: What actually happened (filled during execution)
+- **Status**: Pass/Fail/Blocked/Skipped
+- **Priority**: High/Medium/Low
+- **Test Type**: Unit/Integration/E2E/Accessibility/Performance
+- **Automation Status**: Manual/Automated/Planned
+
+### Example
+
+```
+Test ID: TC-LOGIN-001
+Title: Successful login with valid credentials
+Description: Verify users can log in with correct email and password
+Preconditions: User account exists, system is available
+
+Test Steps:
+1. Navigate to login page
+2. Enter valid email address
+3. Enter valid password
+4. Click 'Sign In' button
+
+Test Data:
+- Email: valid-user@example.com
+- Password: Test123!
+
+Expected Result: User is redirected to dashboard, welcome message displayed
+Actual Result: [Filled during execution]
+Status: [Filled during execution]
+Priority: High
+Test Type: E2E
+Automation Status: Automated
+```
+
+## 2. Test Execution Reporting
+
+### Daily Test Summary
+
+```
+# Daily Test Execution Summary - YYYY-MM-DD
+
+## Execution Overview
+- Total Test Cases: XX
+- Executed: XX (XX%)
+- Passed: XX (XX%)
+- Failed: XX (XX%)
+- Blocked: XX (XX%)
+- Not Run: XX (XX%)
+
+## By Module
+| Module | Total | Executed | Pass | Fail | Block |
+|--------|-------|----------|------|------|-------|
+| Authentication | 15 | 15 | 14 | 1 | 0 |
+| Profile | 12 | 10 | 9 | 1 | 0 |
+| Payments | 20 | 18 | 18 | 0 | 0 |
+| Settings | 8 | 8 | 8 | 0 | 0 |
+
+## Critical Issues
+- [TC-ID] [Brief description of failed test]
+- [TC-ID] [Brief description of failed test]
+
+## Blockers
+- [Description of environment issue preventing test execution]
+- [Description of bug blocking dependent test cases]
+```
+
+### Sprint Test Report
+
+```
+# Sprint [Number] Test Report
+
+## Test Coverage
+| Metric | Target | Actual | Status |
+|--------|--------|--------|--------|
+| Unit Test Coverage | 80% | XX% | [Pass/Fail] |
+| Integration Test Coverage | 80% | XX% | [Pass/Fail] |
+| E2E Test Coverage | 100% of critical paths | XX% | [Pass/Fail] |
+| Accessibility | WCAG 2.1 AA | [Score] | [Pass/Fail] |
+| Performance | Lighthouse >90 | [Score] | [Pass/Fail] |
+
+## Defect Analysis
+| Severity | Open | Resolved | Reopened |
+|----------|------|----------|----------|
+| Critical | X | X | X |
+| High | X | X | X |
+| Medium | X | X | X |
+| Low | X | X | X |
+
+## Quality Trends
+- [Trend 1: e.g., Defect density decreasing week over week]
+- [Trend 2: e.g., Test execution time improved by X%]
+- [Trend 3: e.g., Automated test coverage increased by X%]
+
+## Risks and Concerns
+- [Risk 1: Detailed description with mitigation strategy]
+- [Risk 2: Detailed description with mitigation strategy]
+
+## Recommendations
+- [Recommendation 1: Specific, actionable item]
+- [Recommendation 2: Specific, actionable item]
+```
+
+## 3. Automated Test Documentation
+
+### Code Comments Standard
+
+```typescript
+/**
+ * TC-LOGIN-001: Successful login with valid credentials
+ * 
+ * @description Verifies users can log in with correct email and password, 
+ *              are redirected to dashboard, and see welcome message
+ * @priority High
+ * @type E2E
+ * @automation automated
+ * @status active
+ * @reviewer jane-doe (2025-03-15)
+ */
+ test('user can log in with valid credentials', async ({ page }) => {
+   // Test implementation
+ });
+```
+
+### Test File Structure
+
+```
+src/tests/
+├── features/
+│   ├── auth/
+│   │   ├── login.spec.ts     # E2E tests for login flow
+│   │   ├── register.spec.ts  # E2E tests for registration
+│   │   └── password.spec.ts  # E2E tests for password management
+│   ├── profile/
+│   └── payments/
+├── unit/
+│   ├── services/
+│   └── utils/
+├── integration/
+│   ├── api/
+│   └── database/
+└── accessibility/
+    └── wcag/
+        ├── perceivable.spec.ts
+        ├── operable.spec.ts
+        └── understandable.spec.ts
+```
+
+## 4. Exploratory Testing Documentation
+
+### Session Notes Template
+
+```
+# Exploratory Testing Notes - YYYY-MM-DD
+
+**Tester**: [Name]
+**Session Focus**: [Brief description of exploration area]
+**Duration**: [Start] to [End]
+**Environment**: [Browser, Device, OS, Version]
+
+## Hypotheses
+- [Initial assumption about system behavior]
+- [Another hypothesis to validate]
+
+## Observations
+- [Interesting behavior noticed]
+- [Unexpected system response]
+- [Pattern in user interface interactions]
+
+## Questions
+- [Question about intended functionality]
+- [Question about system limitations]
+
+## Ideas for Further Testing
+- [Specific test scenario to try later]
+- [Edge case to investigate]
+```
+
+## 5. Defect Reporting Standards
+
+### Required Fields
+
+- **Issue ID**: Auto-generated tracking ID
+- **Title**: Concise summary of the problem
+- **Description**: Detailed explanation of the issue
+- **Steps to Reproduce**: Numbered steps to recreate the issue
+- **Expected Result**: What should happen
+- **Actual Result**: What actually happens
+- **Environment**: Browser, OS, device, application version
+- **Attachments**: Screenshots, videos, logs, network traces
+- **Severity**: Critical/High/Medium/Low
+- **Priority**: Immediate/High/Medium/Low
+- **Status**: New/In Progress/Resolved/Verified/Closed
+- **Reproducibility**: Always/Intermittent/Unverified
+
+### Example
+
+```
+Title: Login fails when password contains special characters
+
+Description: When attempting to log in with a password containing certain special characters (!@#$%), the authentication request fails with a 500 error. This occurs consistently for passwords with these characters, but works fine with alphanumeric passwords.
+
+Steps to Reproduce:
+1. Navigate to login page
+2. Enter valid email address
+3. Enter password with special characters (e.g., P@ssw0rd!)
+4. Click 'Sign In' button
+
+Expected Result: User should be authenticated and redirected to dashboard
+Actual Result: Login button spins briefly, then error message "Authentication failed" appears
+
+Environment: Chrome 128.0.6613.138, macOS Sonoma 14.6, Application v2.4.1
+
+Attachments: login-error-screenshot.png, network-trace.har
+
+Severity: High
+Priority: High
+Status: New
+Reproducibility: Always
+```
+
+## 6. Test Metrics and KPIs
+
+### Key Quality Metrics
+
+| Metric | Calculation | Target | Reporting Frequency |
+|--------|-------------|--------|---------------------|
+| Test Coverage | (Tested Requirements / Total Requirements) × 100 | ≥80% | Daily |
+| Defect Density | Defects / KLOC (thousand lines of code) | ≤1.0 | Per Release |
+| Defect Escape Rate | Production Defects / (Total Defects + Production Defects) × 100 | ≤5% | Monthly |
+| Test Execution Pass Rate | Passed Tests / Executed Tests × 100 | ≥95% | Daily |
+| Test Automation Percentage | Automated Tests / Total Tests × 100 | ≥70% | Weekly |
+| Mean Time to Detect (MTTD) | Average time from defect introduction to discovery | ≤24 hours | Weekly |
+| Mean Time to Repair (MTTR) | Average time from defect detection to resolution | ≤4 hours | Weekly |
+
+
+### Quality Dashboard Elements
+
+A comprehensive quality dashboard should include:
+- Current test execution status
+- Trend charts for key metrics over time
+- Defect distribution by module and severity
+- Test coverage by component
+- Automated vs. manual test ratio
+- Build stability and deployment frequency
+- Customer-reported issues
+- Performance metrics
+
+## 7. Documentation Maintenance
+
+### Review Cadence
+- Test cases: Quarterly review and update
+- Test scripts: Update when related functionality changes
+- Test environment documentation: Update after any configuration changes
+- Quality reports: Generated automatically as part of CI/CD pipeline
+
+### Ownership
+- Test cases: QA Engineer responsible for the feature area
+- Test scripts: Developer and QA shared ownership
+- Test environments: DevOps and QA shared ownership
+- Quality metrics: QA Lead
+
+### Version Control
+All test documentation must be:
+- Stored in version control alongside code
+- Linked to requirements and user stories
+- Updated when related functionality changes
+- Reviewed as part of pull request process
\ No newline at end of file
diff --git a/Claude/rules/web/accessibility-testing.md b/Claude/rules/web/accessibility-testing.md
new file mode 100644
index 0000000..b5f3310
--- /dev/null
+++ b/Claude/rules/web/accessibility-testing.md
@@ -0,0 +1,244 @@
+---
+name: web-accessibility-testing
+description: >-
+  Web accessibility rules and guidelines to ensure inclusive experiences for all users.
+  Based on WCAG 2.2 AA compliance with practical implementation guidance.
+priority: CRITICAL
+---
+
+# Web Accessibility Rules
+
+> This file extends [common/accessibility.md](../common/accessibility.md) with web-specific content.
+
+## Core Principles
+
+### POUR Framework
+
+1. **Perceivable** - Information is presentable to users in ways they can perceive
+2. **Operable** - User interface components are operable
+3. **Understandable** - Information and operation are understandable
+4. **Robust** - Content is robust across current and future technologies
+
+### WCAG 2.2 AA Compliance
+
+Mandatory for all public-facing web applications. Must pass automated and manual testing.
+
+## Keyboard Navigation
+
+### Tab Order
+
+- Logical, meaningful sequence through content
+- Follow visual flow (left to right, top to bottom)
+- Skip links must be available for bypassing repetitive content
+- `tabindex="0"` for focusable elements, `tabindex="-1"` for programmatic focus only
+
+### Navigation Components
+
+```tsx
+// Skip navigation
+<a href="#main-content" className="skip-link">
+  Skip to main content
+</a>
+
+// Navigation with proper landmarks
+<nav aria-label="Main navigation">
+  <ul>
+    <li><a href="/home">Home</a></li>
+    <li><a href="/about">About</a></li>
+    <li><a href="/contact">Contact</a></li>
+  </ul>
+</nav>
+```
+
+### Form Controls
+
+- All form fields must have associated labels
+- Use explicit label elements with `for` attributes
+- For visual-only labels, use `aria-label` or `aria-labelledby`
+- Group related controls with `fieldset` and `legend`
+
+```tsx
+// Proper form labeling
+<label htmlFor="email">Email address</label>
+<input type="email" id="email" name="email" required />
+
+// Fieldset for radio groups
+<fieldset>
+  <legend>Choose your preferred contact method</legend>
+  <div>
+    <input type="radio" id="email-contact" name="contact" value="email" />
+    <label htmlFor="email-contact">Email</label>
+  </div>
+  <div>
+    <input type="radio" id="phone-contact" name="contact" value="phone" />
+    <label htmlFor="phone-contact">Phone</label>
+  </div>
+</fieldset>
+```
+
+## Screen Reader Compatibility
+
+### ARIA Implementation
+
+- Use semantic HTML first
+- Apply ARIA roles, states, and properties only when necessary
+- Ensure ARIA attributes are programmatically updated
+- Use `aria-live` regions for dynamic content
+
+```tsx
+// Live region for notifications
+<div aria-live="polite" aria-atomic="true">
+  {notification && <div className="alert">{notification}</div>}
+</div>
+
+// Dynamic content updates
+<div
+  role="alert"
+  aria-atomic="true"
+  aria-live="assertive"
+  className={notification.type === 'error' ? 'error' : 'success'}
+>
+  {notification.message}
+</div>
+```
+
+### Landmark Regions
+
+- Use appropriate ARIA landmarks: banner, navigation, main, complementary, contentinfo
+- Ensure only one `role="main"` per page
+- Provide unique labels for landmark regions when multiple exist
+
+```tsx
+// HTML5 semantic elements with ARIA fallbacks
+<header role="banner">
+  <h1>Site Name</h1>
+</header>
+
+<nav role="navigation" aria-label="Main navigation">
+  <!-- navigation content -->
+</nav>
+
+<main id="main-content" role="main">
+  <!-- main page content -->
+</main>
+
+<footer role="contentinfo">
+  <!-- footer content -->
+</footer>
+```
+
+## Color and Contrast
+
+### Contrast Requirements
+
+- Text and images of text: minimum 4.5:1 contrast ratio
+- Large text (18pt+ or 14pt bold+): minimum 3:1 contrast ratio
+- Non-text contrast (UI components, charts): minimum 3:1 contrast ratio
+- Test in grayscale to ensure information isn't conveyed by color alone
+
+### Color Usage
+
+- Never use color as the only means of conveying information
+- Provide text labels or patterns as alternatives
+- Support both light and dark color schemes
+- Respect `prefers-color-scheme` media query
+
+```css
+/* Respecting color scheme preference */
+@media (prefers-color-scheme: dark) {
+  :root {
+    --surface-bg: #1a1a1a;
+    --text-primary: #ffffff;
+  }
+}
+
+/* High contrast mode support */
+@media (prefers-contrast: high) {
+  :root {
+    --border-thick: 2px;
+  }
+}
+```
+
+## Motion and Animation
+
+### Reduced Motion
+
+- Respect `prefers-reduced-motion` media query
+- Provide alternatives for motion-based interactions
+- Eliminate non-essential animations
+- Allow users to control animation duration
+
+```tsx
+// Conditional animation based on user preference
+const useReducedMotion = () => {
+  const [prefersReducedMotion, setPrefersReducedMotion] = useState(false);
+
+  useEffect(() => {
+    const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
+    setPrefersReducedMotion(mediaQuery.matches);
+    
+    const handleChange = (e) => setPrefersReducedMotion(e.matches);
+    mediaQuery.addEventListener('change', handleChange);
+    
+    return () => mediaQuery.removeEventListener('change', handleChange);
+  }, []);
+
+  return prefersReducedMotion;
+};
+
+// Component using reduced motion preference
+const AnimatedSection = () => {
+  const prefersReducedMotion = useReducedMotion();
+  
+  return (
+    <div
+      className={prefersReducedMotion ? 'static-layout' : 'animated-layout'}
+      style={{
+        transition: prefersReducedMotion 
+          ? 'none' 
+          : 'transform 0.5s cubic-bezier(0.16, 1, 0.3, 1)'
+      }}
+    >
+      {/* content */}
+    </div>
+  );
+};
+```
+
+### Focus Indicators
+
+- Visible focus styles on all interactive elements
+- Do not remove `outline` property without providing equivalent visual indicator
+- Ensure focus indicators have sufficient contrast
+- Test keyboard navigation flow
+
+```css
+/* Preserve focus visibility */
+*:focus-visible {
+  outline: 2px solid var(--color-accent);
+  outline-offset: 2px;
+}
+
+/* Alternative focus style if outline is removed */
+button:focus {
+  outline: none;
+  box-shadow: 0 0 0 2px var(--color-accent);
+}
+```
+
+## Testing Checklist
+
+- [ ] All interactive elements are keyboard accessible
+- [ ] Tab order follows logical sequence
+- [ ] Skip links are present and functional
+- [ ] All form fields have associated labels
+- [ ] ARIA landmarks are properly implemented
+- [ ] Semantic HTML is used appropriately
+- [ ] Color contrast meets WCAG requirements
+- [ ] Information is not conveyed by color alone
+- [ ] `prefers-reduced-motion` is respected
+- [ ] Focus indicators are visible and clear
+- [ ] Screen reader testing performed with NVDA, VoiceOver
+- [ ] Keyboard-only testing completed
+- [ ] Automated accessibility scanning passed (axe, Lighthouse)
\ No newline at end of file
diff --git a/Claude/rules/web/test-pyramid.md b/Claude/rules/web/test-pyramid.md
new file mode 100644
index 0000000..dd1dee1
--- /dev/null
+++ b/Claude/rules/web/test-pyramid.md
@@ -0,0 +1,447 @@
+---
+name: web-test-pyramid
+description: >-
+  Web-specific test pyramid implementation strategy. Defines the optimal balance of
+  unit, integration, and end-to-end tests for web applications.
+priority: CRITICAL
+---
+
+# Test Pyramid for Web Applications
+
+> This file extends [common/test-pyramid.md](../common/test-pyramid.md) with web-specific guidelines.
+
+## Pyramid Structure
+
+```text
+  E2E Tests (10%)  # Critical user flows, cross-system validation
+     │
+     │    Integration Tests (40%)  # API endpoints, component interactions
+     │         │
+     │         │    Unit Tests (50%)  # Components, utilities, hooks, functions
+     │         │         │
+     ▼         ▼         ▼
+  More Time ─────────── Less Time
+  Less Speed ────────── More Speed
+  Higher Cost ───────── Lower Cost
+```
+
+- **Unit Tests (50%)**: Fast, isolated, reliable tests for individual units
+- **Integration Tests (40%)**: Validate interactions between components and systems
+- **E2E Tests (10%)**: Real user scenarios, browser automation, slower execution
+
+## Test Distribution Strategy
+
+### Unit Tests (50%)
+
+Focus on:
+- React components and their behavior
+- Utility functions and data transformations
+- Custom hooks and their state management
+- Business logic and pure functions
+- Type validation and edge cases
+
+```tsx
+// Component unit test example
+import { render, screen, fireEvent } from '@testing-library/react';
+import { Button } from './Button';
+
+describe('Button', () => {
+  it('renders with correct text', () => {
+    render(<Button>Click me</Button>);
+    expect(screen.getByText('Click me')).toBeInTheDocument();
+  });
+
+  it('calls onClick handler when clicked', () => {
+    const handleClick = jest.fn();
+    render(<Button onClick={handleClick}>Click</Button>);
+    
+    fireEvent.click(screen.getByRole('button'));
+    
+    expect(handleClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('displays loading state correctly', () => {
+    render(<Button isLoading>Submit</Button>);
+    expect(screen.getByRole('button')).toBeDisabled();
+    expect(screen.getByText('Loading...')).toBeInTheDocument();
+  });
+});
+```
+
+```tsx
+// Custom hook test example
+import { renderHook, act } from '@testing-library/react-hooks';
+import { useCounter } from './useCounter';
+
+describe('useCounter', () => {
+  it('initializes with default value', () => {
+    const { result } = renderHook(() => useCounter());
+    expect(result.current.count).toBe(0);
+  });
+
+  it('increments count when increment is called', () => {
+    const { result } = renderHook(() => useCounter());
+    
+    act(() => {
+      result.current.increment();
+    });
+    
+    expect(result.current.count).toBe(1);
+  });
+});
+```
+
+### Integration Tests (40%)
+
+Focus on:
+- API endpoints and route handlers
+- Database interactions and queries
+- Third-party service integrations
+- Component composition and interactions
+- State management across components
+- Authentication and authorization flows
+
+```tsx
+// API integration test example
+import { NextRequest } from 'next/server';
+import { GET } from '@/app/api/users/route';
+
+describe('GET /api/users', () => {
+  it('returns users successfully', async () => {
+    const request = new NextRequest('http://localhost/api/users');
+    const response = await GET(request);
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data.success).toBe(true);
+    expect(Array.isArray(data.users)).toBe(true);
+  });
+
+  it('applies filters correctly', async () => {
+    const request = new NextRequest('http://localhost/api/users?role=admin');
+    const response = await GET(request);
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    data.users.forEach(user => {
+      expect(user.role).toBe('admin');
+    });
+  });
+});
+```
+
+```tsx
+// Component integration test
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { UserForm } from '@/components/UserForm';
+import { UserList } from '@/components/UserList';
+
+describe('UserForm and UserList integration', () => {
+  it('adds new user to list when form is submitted', async () => {
+    const user = userEvent.setup();
+    
+    render(\n      <>\n        <UserForm />\n        <UserList />\n      </>\n    );
+
+    // Fill and submit form
+    await user.type(screen.getByLabelText(/name/i), 'John Doe');
+    await user.type(screen.getByLabelText(/email/i), 'john@example.com');
+    await user.click(screen.getByRole('button', { name: /submit/i }));
+
+    // Verify user appears in list
+    await waitFor(() => {
+      expect(screen.getByText('John Doe')).toBeInTheDocument();
+    });
+  });
+});
+```
+
+### End-to-End Tests (10%)
+
+Focus on:
+- Critical user journeys (login, signup, checkout, etc.)
+- Cross-browser compatibility
+- Realistic user interactions
+- Performance and loading behavior
+- Accessibility requirements
+
+```tsx
+// E2E test with Playwright
+import { test, expect } from '@playwright/test';
+
+test('user can complete purchase flow', async ({ page }) => {
+  // Navigate to home
+  await page.goto('/');
+
+  // Add item to cart
+  await page.click('text=Add to Cart');
+  await page.click('text=View Cart');
+
+  // Verify cart contents
+  await expect(page.locator('.cart-item')).toHaveCount(1);
+
+  // Proceed to checkout
+  await page.click('text=Checkout');
+
+  // Fill shipping information
+  await page.fill('input[name="email"]', 'test@example.com');
+  await page.fill('input[name="name"]', 'Test User');
+  await page.fill('input[name="address"]', '123 Main St');
+  await page.fill('input[name="city"]', 'Anytown');
+  
+  // Submit order
+  await page.click('text=Place Order');
+
+  // Verify success
+  await expect(page.locator('text=Order confirmed')).toBeVisible();
+  await expect(page).toHaveURL(/confirmation/);
+});
+```
+
+```tsx
+// Login flow E2E test
+test('user can login and access dashboard', async ({ page }) => {
+  // Navigate to login
+  await page.goto('/login');
+
+  // Fill login form
+  await page.fill('input[name="email"]', 'test@example.com');
+  await page.fill('input[name="password"]', 'password123');
+  await page.click('text=Log In');
+
+  // Verify redirect to dashboard
+  await expect(page).toHaveURL('/dashboard');
+  
+  // Verify dashboard elements
+  await expect(page.locator('h1')).toContainText('Dashboard');
+  await expect(page.getByRole('navigation')).toBeVisible();
+});
+```
+
+## Testing Guidelines
+
+### Test Selection Patterns
+
+| Scenario | Test Type |
+|---------|-----------|
+| Component UI and interactions | Unit test |
+| Data fetching and caching | Integration test |
+| Business logic and validation | Unit test |
+| API endpoint behavior | Integration test |
+| Third-party service integration | Integration test |
+| End-to-end user scenarios | E2E test |
+| Cross-browser compatibility | E2E test |
+| Performance benchmarks | E2E test |
+| Accessibility compliance | E2E test |
+| Complex state management | Integration test |
+
+### Mocking Strategy
+
+#### When to Mock
+
+- External APIs and third-party services
+- Authentication providers
+- Payment processors
+- Analytics and tracking scripts
+- Email and notification services
+- Background jobs and queues
+
+#### When NOT to Mock
+
+- Application state management
+- Core business logic
+- Component interactions within the same feature
+- Local storage and cookies (test actual behavior)
+- Routing within the application
+
+#### Mocking Implementation
+
+```tsx
+// Mock external service
+type MockServiceResponse = {
+  data: any;
+  error: string | null;
+};
+
+const mockService = {
+  fetchData: jest.fn<() => Promise<MockServiceResponse>>(()
+    Promise.resolve({ data: [{ id: 1, name: 'Test' }], error: null })
+  ),
+  updateData: jest.fn(),
+  deleteData: jest.fn()
+};
+
+// In test setup
+beforeEach(() => {
+  jest.resetAllMocks();
+  // Set default mock behavior
+  mockService.fetchData.mockResolvedValue({
+    data: [{ id: 1, name: 'Test Item' }],
+    error: null
+  });
+});
+```
+
+```tsx
+// Mock API route handler
+jest.mock('@/lib/api-client', () => ({
+  fetchUsers: jest.fn(() => Promise.resolve([
+    { id: 1, name: 'John Doe', email: 'john@example.com' }
+  ])),
+  createUser: jest.fn()
+}));
+
+// Mock database
+jest.mock('@/lib/db', () => ({
+  query: jest.fn(),
+  connect: jest.fn()
+}));
+```
+
+## Testing Tools and Frameworks
+
+| Test Type | Recommended Tools |
+|-----------|-------------------|
+| Unit Tests | Jest, Vitest, React Testing Library |
+| Integration Tests | Jest, Vitest, Supertest, React Testing Library |
+| E2E Tests | Playwright, Cypress |
+| Visual Regression | Playwright, Percy, Chromatic |
+| Performance Tests | Lighthouse, WebPageTest |
+| Accessibility Tests | axe, Pa11y, Lighthouse |
+
+## Test Organization
+
+```
+src/
+├── components/
+│   ├── Button/
+│   │   ├── Button.tsx
+│   │   ├── Button.test.tsx          # Unit test
+│   │   └── Button.stories.tsx
+│   └── Form/
+│       ├── Form.tsx
+│       ├── Form.test.tsx
+│       └── __tests__/
+│           ├── Form.integration.test.tsx  # Integration test
+│           └── Form.validation.test.tsx     # Unit test
+├── pages/
+│   ├── api/
+│   │   ├── users/
+│   │   │   ├── route.ts
+│   │   │   └── route.test.ts              # Integration test
+│   │   └── products/
+│   │       ├── route.ts
+│   │       └── route.test.ts
+│   └── __e2e__/
+│       ├── login.test.ts              # E2E test
+│       └── checkout.test.ts           # E2E test
+└── lib/
+    ├── api/
+    │   ├── client.ts
+    │   └── client.test.ts               # Unit test
+    └── auth/
+        ├── index.ts
+        └── auth.test.ts                 # Unit test
+```
+
+## Performance Considerations
+
+- Unit tests should run in < 50ms each
+- Integration tests should run in < 500ms each
+- E2E tests should run in < 10s each (aim for < 5s)
+- Full test suite should complete in < 2 minutes
+- Use test parallelization when possible
+- Mock slow operations in unit and integration tests
+
+## Continuous Integration
+
+```yaml
+# GitHub Actions workflow
+name: Test Suite
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: 18
+       
+    - name: Install dependencies
+      run: npm ci
+      
+    - name: Run unit tests
+      run: npm run test:unit
+      
+    - name: Run integration tests
+      run: npm run test:integration
+      
+    - name: Run E2E tests
+      run: npm run test:e2e
+      
+    - name: Generate coverage report
+      run: npm run test:coverage
+      
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v3
+```
+
+## Testing Checklist
+
+### Unit Tests
+
+- [ ] Test individual components in isolation
+- [ ] Verify component props and state
+- [ ] Test user interactions (clicks, input, etc.)
+- [ ] Verify appropriate ARIA attributes
+- [ ] Test loading and error states
+- [ ] Use appropriate testing library utilities
+- [ ] Mock external dependencies
+- [ ] Keep tests focused and fast
+- [ ] Test edge cases and error handling
+
+### Integration Tests
+
+- [ ] Test API endpoints and route handlers
+- [ ] Verify database interactions
+- [ ] Test component composition
+- [ ] Validate state management
+- [ ] Test authentication flows
+- [ ] Mock external services
+- [ ] Test error handling and edge cases
+- [ ] Verify data transformations
+- [ ] Test caching behavior
+- [ ] Validate security measures
+
+### E2E Tests
+
+- [ ] Test critical user journeys
+- [ ] Verify navigation and routing
+- [ ] Test form submissions
+- [ ] Validate data persistence
+- [ ] Test error scenarios
+- [ ] Verify loading states
+- [ ] Test accessibility requirements
+- [ ] Validate performance metrics
+- [ ] Test cross-browser compatibility
+- [ ] Include visual regression checks
+
+## Success Metrics
+
+- Test suite runs in under 2 minutes
+- 80%+ code coverage achieved
+- No flaky tests (100% pass rate)
+- Critical user flows covered by E2E tests
+- Each bug fix includes a regression test
+- New features include appropriate test coverage
+- Test pyramid ratio maintained (50/40/10)
\ No newline at end of file
diff --git a/Claude/skills/exploratory-testing.md b/Claude/skills/exploratory-testing.md
new file mode 100644
index 0000000..1c677bc
--- /dev/null
+++ b/Claude/skills/exploratory-testing.md
@@ -0,0 +1,265 @@
+---
+name: exploratory-testing
+trigger: "use PROACTIVELY when conducting QA, debugging, or user testing"
+description: Comprehensive guide to exploratory testing methodologies, charter development, session reporting, and best practices.
+---
+
+# Exploratory Testing Mastery
+
+Practical framework for structured exploratory testing that balances freedom with accountability. Based on ISTQB best practices and real-world application.
+
+## 1. Exploratory Testing Charters
+
+A charter defines the mission and scope for a testing session. It should be specific enough to provide direction, but flexible enough to allow discovery.
+
+### Charter Template
+
+```
+**Mission**: [What are you trying to achieve?]
+**Scope**: [Specific features/components to explore]
+**Risks**: [Known risk areas to investigate]
+**Timebox**: [Duration of session, typically 60-90 minutes]
+**Reference Materials**: [PRs, requirements, user stories to review]
+**Success Metrics**: [What does a successful session look like?]
+```
+
+### Example Charters
+
+**Authentication Flow Exploration**
+```
+Mission: Uncover edge cases in the multi-factor authentication flow
+Scope: Login page, 2FA entry, recovery codes, biometric authentication
+Risks: Session hijacking, brute force attacks, accessibility issues
+Timebox: 75 minutes
+Reference Materials: PR #1423, Security RFC-2024-001, User Story AUTH-45
+Success Metrics: Discover at least 3 edge cases, document 2 potential security improvements
+```
+
+**Checkout Process Resilience**
+```
+Mission: Test system behavior under failure conditions during checkout
+Scope: Payment processing, order confirmation, email notifications
+Risks: Payment gateway timeouts, inventory race conditions, network interruptions
+Timebox: 90 minutes
+Reference Materials: Payment Integration Doc v2.3, Order Service Architecture
+Success Metrics: Identify failure recovery gaps, suggest 3 resilience improvements
+```
+
+## 2. Test Session Structure
+
+Follow a disciplined approach to ensure productive sessions:
+
+### Pre-Session Preparation
+- Review charter and reference materials
+- Set up test environment and data
+- Configure necessary tools (browser dev tools, network throttling, etc.)
+- Document starting state
+
+### Session Execution (90-Minute Format)
+```
+0-15 min:  Familiarization & hypothesis generation
+15-60 min: Deep exploration with varied inputs and sequences
+60-75 min: Focus on highest-risk areas identified
+75-90 min: Wrap-up and initial findings documentation
+```
+
+### Heuristic Test Strategy Model (HTSM)
+
+Use these dimensions to guide exploration:
+
+**FUNCTIONS**: What does it do? What doesn't it do?
+**DATA**: Valid/invalid inputs, boundary conditions, data dependencies
+**PLATFORMS**: Different browsers, devices, operating systems
+**OPERATIONS**: Typical user workflows, edge case scenarios
+**TIME**: Performance under load, timing dependencies, timeouts
+
+## 3. Session Reporting
+
+Document findings in a structured format that enables action:
+
+### Minimal Session Report
+```
+# Exploratory Testing Session Report
+
+**Date**: YYYY-MM-DD
+**Tester**: [Name]
+**Charter**: [Mission]
+**Duration**: [Start Time] - [End Time] ([Total Minutes] min)
+
+## Summary
+[2-3 sentence overview of key findings]
+
+## Areas Explored
+- [Feature/Component 1]
+- [Feature/Component 2]
+- [Feature/Component 3]
+
+## Findings
+
+### Critical Issues
+- [Issue 1: Brief description with reproduction steps]
+- [Issue 2: Brief description with reproduction steps]
+
+### Improvement Opportunities
+- [Suggestion 1: Clear, actionable recommendation]
+- [Suggestion 2: Clear, actionable recommendation]
+
+### Questions for Team
+- [Question 1: Specific question requiring clarification]
+- [Question 2: Specific question about expected behavior]
+
+## Time Allocation
+- Familiarization: X minutes
+- Deep exploration: X minutes
+- Focus on risks: X minutes
+- Documentation: X minutes
+
+## Confidence Rating
+[High/Medium/Low] - [Brief justification]
+```
+
+### Example Session Report
+```
+# Exploratory Testing Session Report
+
+**Date**: 2025-03-15
+**Tester**: Jane Doe
+**Charter**: Authentication Flow Exploration
+**Duration**: 10:00 - 11:15 (75 min)
+
+## Summary
+Uncovered three edge cases in 2FA recovery flow and identified accessibility gaps in biometric authentication. Discovered potential session fixation vulnerability when switching authentication methods.
+
+## Areas Explored
+- Login with email/password
+- SMS-based 2FA
+- Authenticator app 2FA
+- Biometric authentication (Touch ID)
+- Recovery code generation and use
+- Authentication method switching
+
+## Findings
+
+### Critical Issues
+- Session not invalidated when switching from password to biometric authentication, creating session fixation risk
+- Recovery codes not properly rate-limited, enabling brute force attacks
+- Biometric fallback not available when Face ID fails multiple times
+
+### Improvement Opportunities
+- Implement step-up authentication when switching authentication methods
+- Add progressive rate limiting for recovery code attempts
+- Provide alternative 2FA method when biometrics fail
+- Enhance error messages for failed biometric attempts
+
+### Questions for Team
+- What is the expected behavior when a user's biometric enrollment changes (e.g., new phone)?
+- Are there plans to support security keys as a 2FA option?
+
+## Time Allocation
+- Familiarization: 12 minutes
+- Deep exploration: 48 minutes
+- Focus on risks: 10 minutes
+- Documentation: 5 minutes
+
+## Confidence Rating
+Medium - Covered primary attack vectors but limited time to test edge network conditions
+```
+
+## 4. Exploratory Testing Techniques
+
+### Touring Heuristics
+Apply these mental models during exploration:
+
+**Bug Taxonomy Tour**: Systematically test for common bug patterns:
+- Input validation failures
+- Error handling gaps
+- State management issues
+- Race conditions
+- Security vulnerabilities
+- Accessibility barriers
+
+**Quality Attributes Tour**: Focus on non-functional aspects:
+- Performance under various loads
+- Usability across different user personas
+- Reliability during network interruptions
+- Security against common attack vectors
+- Compatibility across platforms
+
+**Data Life Cycle Tour**: Follow data from creation to deletion:
+- Data entry and validation
+- Data storage and encryption
+- Data processing and transformation
+- Data display and formatting
+- Data sharing and export
+- Data deletion and retention
+
+### Session-Based Test Management (SBTM)
+
+Track exploratory testing as a structured practice:
+
+```
+| Session | Charter | Tester | Date | Duration | Bugs Found | Status |
+|---------|---------|--------|------|----------|------------|--------|
+| 001 | Auth Flow Exploration | Jane Doe | 2025-03-15 | 75 min | 3 | Complete |
+| 002 | Checkout Resilience | John Smith | 2025-03-16 | 90 min | 5 | Complete |
+| 003 | Search Relevance | Jane Doe | 2025-03-17 | 60 min | 2 | In Progress |
+```
+
+## 5. Integrating with Agile Workflow
+
+### When to Use Exploratory Testing
+- After major feature implementation
+- Before production releases
+- In response to user-reported issues
+- Following security incidents
+- When automated tests fail to catch critical bugs
+
+### Complementary Practices
+- Pair testing with developers or product owners
+- Bug bash sessions before releases
+- Context-driven test tours for new team members
+- Exploratory testing workshops to share findings
+
+## 6. Advanced Techniques
+
+### Exploratory Automation
+Combine exploratory principles with automation:
+
+```javascript
+// Randomized input generator for form testing
+function generateRandomUser() {
+  return {
+    email: `${randomString(8)}@${randomDomain()}`,
+    password: generateStrongPassword(),
+    age: randomInt(13, 100),
+    phone: generatePhoneNumber()
+  };
+}
+
+// Property-based testing for API endpoints
+function testAPIEndpointProperty(endpoint, property, generator) {
+  const testCases = Array.from({length: 100}, () => generator());
+  
+  testCases.forEach(testCase => {
+    const response = callAPI(endpoint, testCase);
+    assert(property(response, testCase), 
+      `Property violation for input: ${JSON.stringify(testCase)}`);
+  });
+}
+```
+
+### Cognitive Bias Mitigation
+
+Common biases and countermeasures:
+
+**Confirmation Bias**: Seek to disprove hypotheses, not confirm them
+**Automation Bias**: Don't trust automated results blindly; verify manually
+**Anchoring Bias**: Don't fixate on first observed behavior; explore alternatives
+**Availability Bias**: Don't focus only on obvious test areas; use checklists
+
+## 7. References
+
+- ISTQB Advanced Level Test Analyst Syllabus
+- Cem Kaner's "Exploratory Testing" concepts
+- James Bach's "Session-Based Test Management"
+- "Lessons Learned in Software Testing" by Cem Kaner, James Bach, and Bret Pettichord
\ No newline at end of file
diff --git a/Claude/skills/manual-testing.md b/Claude/skills/manual-testing.md
new file mode 100644
index 0000000..162e61e
--- /dev/null
+++ b/Claude/skills/manual-testing.md
@@ -0,0 +1,64 @@
+---
+name: manual-testing
+description: Manual testing strategies including test planning, case design, exploratory testing, bug reporting, and quality assurance processes.
+origin: ECC
+---
+
+# Manual Testing Guide
+
+Comprehensive manual testing strategies for ensuring software quality through systematic test planning, execution, and reporting.
+
+## Test Planning
+
+### Test Strategy Development
+
+1. **Define Objectives**:
+   - Identify key features to test
+   - Determine testing scope and boundaries
+   - Establish success criteria
+
+2. **Risk Assessment**:
+   - Identify high-risk areas (financial, security, core functionality)
+   - Prioritize testing based on risk level
+   - Allocate resources accordingly
+
+3. **Test Environment Setup**:
+   - Replicate production-like conditions
+   - Document environment configuration
+   - Ensure test data availability
+
+4. **Schedule and Resources**:
+   - Create realistic timelines
+   - Assign team members to specific areas
+   - Plan for contingencies
+
+### Test Charter (Session-Based Testing)
+
+```markdown
+# Test Charter: User Authentication
+
+**Objective**: Verify login functionality across all supported scenarios
+
+**Scope**:
+- Email/password login
+- Social login (Google, GitHub)
+- Password reset flows
+- Account lockout policies
+
+**Risks**:
+- Security vulnerabilities
+- Third-party service failures
+- Edge cases in validation
+
+**Data Requirements**:
+- Valid test accounts
+- Invalid credentials
+- Locked/blocked accounts
+
+**Tools**:
+- Browser developer tools
+- Network monitoring
+- Screenshot tool
+
+**Duration**: 90 minutes
+```
\ No newline at end of file
diff --git a/Claude/skills/quality-metrics.md b/Claude/skills/quality-metrics.md
new file mode 100644
index 0000000..6a247ee
--- /dev/null
+++ b/Claude/skills/quality-metrics.md
@@ -0,0 +1,1573 @@
+---
+type: skill
+name: quality-metrics
+description: Comprehensive framework for measuring, tracking, and improving software quality through actionable metrics, KPIs, and continuous improvement practices.
+origin: ECC
+---
+
+# Quality Metrics Framework
+
+Strategic approach to defining, collecting, and acting on software quality metrics that drive continuous improvement and business value.
+
+## Quality KPIs and Metrics
+
+### Defect Management Metrics
+
+```markdown
+# Defect Management Dashboard
+
+## Key Metrics
+
+| Metric | Formula | Target | Current | Status |
+|--------|---------|--------|---------|--------|
+| Defect Density | Total Defects / KLOC | ≤ 1.0 | 0.8 | ✅ | |
+| Critical Defect Resolution Time | Avg. time to resolve P0/P1 defects | ≤ 4h | 3.2h | ✅ |
+| Defect Reopen Rate | Reopened Defects / Total Resolved | ≤ 5% | 3.8% | ✅ |
+| Test Escape Rate | Production Defects / Total Defects | ≤ 10% | 8.5% | ✅ |
+| Defect Turnaround Time | Avg. time from report to resolution | ≤ 24h | 18.5h | ✅ |
+
+## Defect Trends (Last 8 Weeks)
+
+```mermaid
+lineChart
+    title Defect Trends
+    x-axis Week
+    y-axis Count
+    series Reported, Resolved
+    Reported : 45, 38, 42, 36, 39, 33, 30, 28
+    Resolved : 32, 41, 39, 40, 37, 35, 34, 31
+```
+
+## Defect Distribution
+
+```mermaid
+pie
+    title Defect Priority Distribution
+    "P0: Critical" : 5
+    "P1: High" : 12
+    "P2: Medium" : 25
+    "P3: Low" : 18
+```
+
+```mermaid
+pie
+    title Defect Origin
+    "Frontend" : 24
+    "Backend" : 28
+    "Integration" : 12
+    "Infrastructure" : 6
+    "Documentation" : 10
+```
+
+## Action Items
+
+- Investigate increase in P1 defects from integration points
+- Review test coverage for backend components with highest defect density
+- Conduct root cause analysis for reopened defects
+```
+
+### Test Coverage Metrics
+
+```markdown
+# Test Coverage Dashboard
+
+## Coverage Summary
+
+| Component | Unit Coverage | Integration Coverage | E2E Coverage | Total Coverage |
+|-----------|---------------|----------------------|--------------|----------------|
+| Authentication | 98% | 95% | 100% | 97.7% |
+| Payment Processing | 95% | 92% | 100% | 95.7% |
+| User Management | 92% | 88% | 95% | 91.7% |
+| Reporting | 85% | 80% | 90% | 85.0% |
+| API Gateway | 90% | 85% | 95% | 90.0% |
+| Overall | 92% | 88% | 96% | 92.0% |
+
+## Coverage Trends (Last 6 Months)
+
+```mermaid
+lineChart
+    title Test Coverage Trends
+    x-axis Month
+    y-axis Percentage
+    series Unit, Integration, E2E, Overall
+    Unit : 88, 89, 90, 91, 91.5, 92
+    Integration : 82, 83, 84, 86, 87, 88
+    E2E : 90, 91, 92, 93, 94, 96
+    Overall : 86.7, 87.7, 88.7, 89.7, 90.2, 92.0
+```
+
+## Gaps Analysis
+
+### Low Coverage Areas
+
+1. **Error Handling Paths** (Current: 65%)
+   - Missing negative test cases for edge conditions
+   - Insufficient validation of malformed inputs
+   - Limited testing of third-party service failures
+
+2. **Concurrent Operations** (Current: 70%)
+   - Race condition scenarios not adequately tested
+   - Limited stress testing for high-concurrency scenarios
+   - Incomplete testing of distributed locking mechanisms
+
+3. **Security Controls** (Current: 75%)
+   - Authentication bypass scenarios missing
+   - Insufficient authorization testing for role transitions
+   - Limited testing of CSRF and XSRF protections
+
+## Action Plan
+
+| Initiative | Owner | Target Date | Status |
+|-----------|-------|-------------|--------|
+| Implement mutation testing | QA Lead | 2025-06-30 | In Progress |
+| Expand negative test suite | Test Engineer | 2025-05-15 | Planned |
+| Add concurrency stress tests | SDET | 2025-07-31 | Research |
+| Enhance security test coverage | Security Engineer | 2025-06-15 | Planned |
+```
+
+### Release Quality Metrics
+
+```markdown
+# Release Quality Dashboard
+
+## Release Metrics
+
+| Release | Version | UAT Defects | P0/P1 in Prod | Rollback | Business Impact | Quality Score |
+|---------|---------|-------------|---------------|----------|----------------|---------------|
+| 2025-03-15 | 2.3.1 | 5 | 0 | No | Minimal | 9.2/10 |
+| 2025-02-28 | 2.3.0 | 12 | 1 | No | Low | 8.1/10 |
+| 2025-02-10 | 2.2.5 | 8 | 2 | Yes | Medium | 6.5/10 |
+| 2025-01-25 | 2.2.4 | 6 | 0 | No | Minimal | 9.0/10 |
+| 2025-01-05 | 2.2.3 | 15 | 3 | Yes | High | 5.8/10 |
+
+## Deployment Success Rate
+
+```mermaid
+lineChart
+    title Deployment Success Rate
+    x-axis Week
+    y-axis Percentage
+    series Success Rate
+    Success Rate : 100, 100, 85, 100, 70, 100, 100, 100
+```
+
+## Post-Deployment Monitoring
+
+### Performance Impact
+
+| Metric | Pre-Release | Post-Release | Delta | Status |
+|--------|-------------|--------------|-------|--------|
+| API Response Time | 215ms | 228ms | +13ms | ⚠️ |
+| Error Rate | 0.45% | 0.52% | +0.07% | ⚠️ |
+| Throughput | 1,240 req/s | 1,180 req/s | -60 req/s | ⚠️ |
+| Cache Hit Rate | 92.3% | 91.8% | -0.5% | ✅ |
+
+### Business Impact
+
+```mermaid
+pie
+    title User Feedback
+    "Positive" : 45
+    "Neutral" : 30
+    "Negative" : 25
+```
+
+```mermaid
+pie
+    title Issue Categories
+    "UI/UX" : 40
+    "Performance" : 25
+    "Missing Features" : 20
+    "Bugs" : 15
+```
+
+## Release Process Improvements
+
+1. **Enhanced Pre-Release Checklist**
+   - Add performance regression gates
+   - Implement security scan requirements
+   - Require test coverage minimums
+
+2. **Improved Rollback Procedures**
+   - Automate rollback triggers based on health checks
+   - Implement blue-green deployment strategy
+   - Add database migration rollback plans
+
+3. **Post-Mortem Process**
+   - Conduct blameless post-mortems for failed releases
+   - Track action items to resolution
+   - Share learnings across teams
+```
+
+## Metrics Collection Framework
+
+### Automated Metrics Pipeline
+
+```yaml
+# .github/workflows/quality-metrics.yml
+name: Quality Metrics Collection
+
+on:
+  schedule:
+    - cron: '0 2 * * 1'  # Run every Monday at 2 AM
+  workflow_dispatch:
+
+jobs:
+  collect-metrics:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '18'
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Extract test results
+      run: |
+        # Collect JUnit test results
+        mkdir -p metrics/test-results
+        find . -name "TEST-*.xml" -exec cp {} metrics/test-results/ \; 2>/dev/null || true
+        
+        # Generate coverage report
+        npm run test:coverage -- --output-file=metrics/coverage.json
+
+    - name: Run static analysis
+      run: |
+        # Run ESLint and generate report
+        npx eslint . --format=json --output-file=metrics/eslint.json
+        
+        # Run SonarQube scanner
+        npx sonarqube-scanner
+
+    - name: Collect CI/CD metrics
+      run: |
+        # Get recent pipeline data
+        gh api 
+          -X GET
+          -H "Accept: application/vnd.github.v3+json"
+          "/repos/${{ github.repository }}/actions/runs?per_page=100"
+          > metrics/pipeline_runs.json
+        
+        # Get deployment data
+        gh api 
+          -X GET
+          -H "Accept: application/vnd.github.v3+json"
+          "/repos/${{ github.repository }}/deployments?per_page=100"
+          > metrics/deployments.json
+
+    - name: Generate quality dashboard
+      run: |
+        # Run metrics processing script
+        node scripts/generate-quality-dashboard.js
+        
+        # Update README with latest metrics
+        node scripts/update-readme-metrics.js
+
+    - name: Commit and push updates
+      run: |
+        git config user.name 'github-actions'
+        git config user.email 'github-actions@github.com'
+        
+        # Only commit if there are changes
+        if [ -n "$(git status --porcelain)" ]; then
+          git add .
+          git commit -m "[automated] Update quality metrics $(date +%Y-%m-%d)"
+          git push
+        fi
+```
+
+### Metrics Processing Script
+
+```javascript
+// scripts/generate-quality-dashboard.js
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+const jsYaml = require('js-yaml');
+
+// Configuration
+const CONFIG = {
+  metricsPath: './metrics',
+  outputPath: './docs/dashboards',
+  services: {
+    sonarqube: 'https://sonarqube.example.com',
+    jenkins: 'https://jenkins.example.com',
+    datadog: 'https://api.datadoghq.com'
+  }
+};
+
+class MetricsProcessor {
+  constructor() {
+    this.metrics = {
+      test: {},
+      coverage: {},
+      defects: {},
+      performance: {},
+      ci_cd: {}
+    };
+  }
+
+  async processAllMetrics() {
+    console.log('Starting metrics processing...');
+    
+    try {
+      // Load raw data
+      await this.loadTestData();
+      await this.loadCoverageData();
+      await this.loadDefectData();
+      await this.loadPerformanceData();
+      await this.loadCiCdData();
+      
+      // Calculate KPIs
+      this.calculateTestKpis();
+      this.calculateCoverageKpis();
+      this.calculateDefectKpis();
+      this.calculatePerformanceKpis();
+      this.calculateCiCdKpis();
+      
+      // Generate dashboards
+      await this.generateDashboards();
+      
+      // Save processed metrics
+      this.saveProcessedMetrics();
+      
+      console.log('Metrics processing completed successfully');
+      
+    } catch (error) {
+      console.error('Error processing metrics:', error);
+      throw error;
+    }
+  }
+
+  async loadTestData() {
+    console.log('Loading test data...');
+    
+    const testResultsPath = path.join(CONFIG.metricsPath, 'test-results');
+    const testFiles = fs.readdirSync(testResultsPath);
+    
+    const testResults = [];
+    for (const file of testFiles) {
+      if (file.endsWith('.xml')) {
+        const content = fs.readFileSync(path.join(testResultsPath, file), 'utf8');
+        const parsed = this.parseJUnitXml(content);
+        testResults.push(...parsed.testsuites[0].testcase);
+      }
+    }
+    
+    this.metrics.test.raw = testResults;
+  }
+
+  async loadCoverageData() {
+    console.log('Loading coverage data...');
+    
+    const coveragePath = path.join(CONFIG.metricsPath, 'coverage.json');
+    if (fs.existsSync(coveragePath)) {
+      const coverageData = JSON.parse(fs.readFileSync(coveragePath, 'utf8'));
+      this.metrics.coverage.raw = coverageData;
+    }
+  }
+
+  async loadDefectData() {
+    console.log('Loading defect data...');
+    
+    // Fetch from Jira or other issue tracking system
+    try {
+      const response = await axios.get(
+        `${CONFIG.services.jira}/rest/api/3/search`,
+        {
+          params: {
+            jql: 'project=QUALITY AND created >= -8w ORDER BY created DESC',
+            fields: 'summary,status,priority,created,updated'
+          },
+          headers: {
+            'Authorization': `Basic ${Buffer.from(process.env.JIRA_USER + ':' + process.env.JIRA_TOKEN).toString('base64')}`
+          }
+        }
+      );
+      
+      this.metrics.defects.raw = response.data.issues;
+      
+    } catch (error) {
+      console.warn('Could not fetch defect data:', error.message);
+      // Use fallback data
+      this.metrics.defects.raw = this.loadLocalDefectData();
+    }
+  }
+
+  loadLocalDefectData() {
+    // Load from local file if Jira is unavailable
+    const localPath = path.join(CONFIG.metricsPath, 'local-defects.json');
+    if (fs.existsSync(localPath)) {
+      return JSON.parse(fs.readFileSync(localPath, 'utf8'));
+    }
+    return [];
+  }
+
+  async loadPerformanceData() {
+    console.log('Loading performance data...');
+    
+    // Fetch from monitoring system
+    try {
+      const [responseTime, errorRate, throughput] = await Promise.all([
+        axios.get(`${CONFIG.services.datadog}/api/v1/metrics/query`, {
+          params: {
+            query: 'avg:api.response.time{env:production}.as_rate()'
+          },
+          headers: {
+            'DD-API-KEY': process.env.DATADOG_API_KEY
+          }
+        }),
+        axios.get(`${CONFIG.services.datadog}/api/v1/metrics/query`, {
+          params: {
+            query: 'avg:api.error.rate{env:production}.as_rate()'
+          },
+          headers: {
+            'DD-API-KEY': process.env.DATADOG_API_KEY
+          }
+        }),
+        axios.get(`${CONFIG.services.datadog}/api/v1/metrics/query`, {
+          params: {
+            query: 'avg:api.throughput{env:production}.as_rate()'
+          },
+          headers: {
+            'DD-API-KEY': process.env.DATADOG_API_KEY
+          }
+        })
+      ]);
+      
+      this.metrics.performance.response_time = responseTime.data;
+      this.metrics.performance.error_rate = errorRate.data;
+      this.metrics.performance.throughput = throughput.data;
+      
+    } catch (error) {
+      console.warn('Could not fetch performance data:', error.message);
+    }
+  }
+
+  async loadCiCdData() {
+    console.log('Loading CI/CD data...');
+    
+    const pipelineRunsPath = path.join(CONFIG.metricsPath, 'pipeline_runs.json');
+    const deploymentsPath = path.join(CONFIG.metricsPath, 'deployments.json');
+    
+    if (fs.existsSync(pipelineRunsPath)) {
+      this.metrics.ci_cd.pipeline_runs = JSON.parse(
+        fs.readFileSync(pipelineRunsPath, 'utf8')
+      );
+    }
+    
+    if (fs.existsSync(deploymentsPath)) {
+      this.metrics.ci_cd.deployments = JSON.parse(
+        fs.readFileSync(deploymentsPath, 'utf8')
+      );
+    }
+  }
+
+  calculateTestKpis() {
+    console.log('Calculating test KPIs...');
+    
+    const tests = this.metrics.test.raw;
+    
+    this.metrics.test.kpis = {
+      total_tests: tests.length,
+      passed: tests.filter(t => !t.failure && !t.error).length,
+      failed: tests.filter(t => t.failure || t.error).length,
+      skipped: tests.filter(t => t.$.status === 'skipped').length,
+      pass_rate: 0,
+      average_duration: 0
+    };
+    
+    // Calculate pass rate
+    this.metrics.test.kpis.pass_rate = 
+      parseFloat(((this.metrics.test.kpis.passed / tests.length) * 100).toFixed(2));
+    
+    // Calculate average duration
+    const durations = tests.map(t => parseFloat(t.$.time) || 0);
+    this.metrics.test.kpis.average_duration = 
+      parseFloat((durations.reduce((a, b) => a + b, 0) / durations.length).toFixed(3));
+    
+    // Failure trends
+    this.metrics.test.kpis.failure_trends = this.calculateTrendData(
+      tests, 'day', (t) => new Date(t.$.timestamp || t.$.time).toISOString().split('T')[0]
+    );
+  }
+
+  calculateCoverageKpis() {
+    console.log('Calculating coverage KPIs...');
+    
+    const raw = this.metrics.coverage.raw;
+    
+    if (raw && raw.total) {
+      const total = raw.total;
+      
+      this.metrics.coverage.kpis = {
+        lines: {
+          covered: total.lines.covered,
+          total: total.lines.total,
+          percentage: parseFloat(((total.lines.covered / total.lines.total) * 100).toFixed(2))
+        },
+        statements: {
+          covered: total.statements.covered,
+          total: total.statements.total,
+          percentage: parseFloat(((total.statements.covered / total.statements.total) * 100).toFixed(2))
+        },
+        functions: {
+          covered: total.functions.covered,
+          total: total.functions.total,
+          percentage: parseFloat(((total.functions.covered / total.functions.total) * 100).toFixed(2))
+        },
+        branches: {
+          covered: total.branches.covered,
+          total: total.branches.total,
+          percentage: parseFloat(((total.branches.covered / total.branches.total) * 100).toFixed(2))
+        }
+      };
+    }
+  }
+
+  calculateDefectKpis() {
+    console.log('Calculating defect KPIs...');
+    
+    const defects = this.metrics.defects.raw;
+    const now = new Date();
+    
+    // Filter recent defects
+    const recentDefects = defects.filter(d => 
+      new Date(d.fields.created) > new Date(now.getTime() - 8 * 7 * 24 * 60 * 60 * 1000)
+    );
+    
+    // Count by priority
+    const priorityCounts = this.countBy(recentDefects, d => d.fields.priority.name);
+    
+    this.metrics.defects.kpis = {
+      total: recentDefects.length,
+      by_priority: priorityCounts,
+      p0_p1_count: (priorityCounts['Critical'] || 0) + (priorityCounts['High'] || 0),
+      reopen_rate: 0, // Would need resolution history
+      average_resolution_time: 0, // Would need resolution dates
+      trends: this.calculateTrendData(
+        recentDefects, 'week', (d) => this.getWeekString(new Date(d.fields.created))
+      )
+    };
+  }
+
+  calculatePerformanceKpis() {
+    console.log('Calculating performance KPIs...');
+    
+    const responseTime = this.metrics.performance.response_time;
+    const errorRate = this.metrics.performance.error_rate;
+    const throughput = this.metrics.performance.throughput;
+    
+    if (responseTime && responseTime.series && responseTime.series[0]) {
+      const points = responseTime.series[0].pointlist;
+      const values = points.map(p => p[1]).filter(v => v !== null);
+      
+      this.metrics.performance.kpis = {
+        response_time: {
+          average: parseFloat((values.reduce((a, b) => a + b, 0) / values.length).toFixed(2)),
+          p95: parseFloat(this.getPercentile(values, 95).toFixed(2)),
+          p99: parseFloat(this.getPercentile(values, 99).toFixed(2))
+        }
+      };
+    }
+  }
+
+  calculateCiCdKpis() {
+    console.log('Calculating CI/CD KPIs...');
+    
+    const pipelineRuns = this.metrics.ci_cd.pipeline_runs?.workflow_runs || [];
+    const deployments = this.metrics.ci_cd.deployments || [];
+    
+    // Filter recent pipeline runs
+    const recentRuns = pipelineRuns.filter(run => 
+      new Date(run.created_at) > new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
+    );
+    
+    // Calculate success rate
+    const successfulRuns = recentRuns.filter(run => run.conclusion === 'success').length;
+    const totalRuns = recentRuns.length;
+    
+    this.metrics.ci_cd.kpis = {
+      pipeline_success_rate: totalRuns > 0 ? 
+        parseFloat(((successfulRuns / totalRuns) * 100).toFixed(2)) : 100,
+      average_duration: 0,
+      deployment_frequency: deployments.length / 4, // Per week
+      lead_time: this.calculateLeadTime(deployments),
+      rollback_rate: this.calculateRollbackRate(deployments)
+    };
+    
+    // Average duration
+    if (recentRuns.length > 0) {
+      const durations = recentRuns.map(run => {
+        const createdAt = new Date(run.created_at);
+        const updatedAt = new Date(run.updated_at);
+        return (updatedAt - createdAt) / 1000; // seconds
+      });
+      this.metrics.ci_cd.kpis.average_duration = 
+        parseFloat((durations.reduce((a, b) => a + b, 0) / durations.length / 60).toFixed(2)); // minutes
+    }
+  }
+
+  async generateDashboards() {
+    console.log('Generating dashboards...');
+    
+    // Ensure output directory exists
+    if (!fs.existsSync(CONFIG.outputPath)) {
+      fs.mkdirSync(CONFIG.outputPath, { recursive: true });
+    }
+    
+    // Generate Markdown dashboard
+    const markdownDashboard = this.generateMarkdownDashboard();
+    fs.writeFileSync(
+      path.join(CONFIG.outputPath, 'quality-dashboard.md'), 
+      markdownDashboard
+    );
+    
+    // Generate JSON dashboard for API consumption
+    const jsonDashboard = this.generateJsonDashboard();
+    fs.writeFileSync(
+      path.join(CONFIG.outputPath, 'quality-dashboard.json'), 
+      JSON.stringify(jsonDashboard, null, 2)
+    );
+  }
+
+  generateMarkdownDashboard() {
+    return `# Quality Metrics Dashboard
+
+Last updated: ${new Date().toISOString()}
+
+## Test Execution
+
+- **Total Tests**: ${this.metrics.test.kpis.total_tests}
+- **Pass Rate**: ${this.metrics.test.kpis.pass_rate}%
+- **Failed Tests**: ${this.metrics.test.kpis.failed}
+- **Average Duration**: ${this.metrics.test.kpis.average_duration}s
+
+## Code Coverage
+
+| Metric | Covered | Total | Percentage |
+|--------|---------|-------|------------|
+| Lines | ${this.metrics.coverage.kpis?.lines?.covered || 0} | ${this.metrics.coverage.kpis?.lines?.total || 0} | ${this.metrics.coverage.kpis?.lines?.percentage || 0}% |
+| Statements | ${this.metrics.coverage.kpis?.statements?.covered || 0} | ${this.metrics.coverage.kpis?.statements?.total || 0} | ${this.metrics.coverage.kpis?.statements?.percentage || 0}% |
+| Functions | ${this.metrics.coverage.kpis?.functions?.covered || 0} | ${this.metrics.coverage.kpis?.functions?.total || 0} | ${this.metrics.coverage.kpis?.functions?.percentage || 0}% |
+| Branches | ${this.metrics.coverage.kpis?.branches?.covered || 0} | ${this.metrics.coverage.kpis?.branches?.total || 0} | ${this.metrics.coverage.kpis?.branches?.percentage || 0}% |
+
+## Defects (Last 8 Weeks)
+
+- **Total Defects**: ${this.metrics.defects.kpis.total}
+- **Critical/High Defects**: ${this.metrics.defects.kpis.p0_p1_count}
+- **Defect Trends**: See chart below
+
+
+e```mermaid
+lineChart
+    title Defect Trends
+    x-axis Week
+    y-axis Count
+    series Defects
+    Defects : ${this.metrics.defects.kpis.trends.map(t => t.count).join(', ')}
+```
+
+## CI/CD Metrics
+
+- **Pipeline Success Rate**: ${this.metrics.ci_cd.kpis.pipeline_success_rate}%
+- **Average Pipeline Duration**: ${this.metrics.ci_cd.kpis.average_duration} minutes
+- **Deployment Frequency**: ${this.metrics.ci_cd.kpis.deployment_frequency.toFixed(1)} per week
+- **Lead Time for Changes**: ${this.metrics.ci_cd.kpis.lead_time} days
+- **Rollback Rate**: ${this.metrics.ci_cd.kpis.rollback_rate}%
+
+## Performance (Production)
+
+- **Average Response Time**: ${this.metrics.performance.kpis?.response_time?.average || 'N/A'}ms
+- **P95 Response Time**: ${this.metrics.performance.kpis?.response_time?.p95 || 'N/A'}ms
+- **P99 Response Time**: ${this.metrics.performance.kpis?.response_time?.p99 || 'N/A'}ms
+`;  }
+
+  generateJsonDashboard() {
+    return {
+      timestamp: new Date().toISOString(),
+      version: '1.0.0',
+      metrics: {
+        test: this.metrics.test.kpis,
+        coverage: this.metrics.coverage.kpis,
+        defects: this.metrics.defects.kpis,
+        ci_cd: this.metrics.ci_cd.kpis,
+        performance: this.metrics.performance.kpis
+      }
+    };
+  }
+
+  saveProcessedMetrics() {
+    console.log('Saving processed metrics...');
+    
+    const outputPath = path.join(CONFIG.metricsPath, 'processed');
+    if (!fs.existsSync(outputPath)) {
+      fs.mkdirSync(outputPath, { recursive: true });
+    }
+    
+    fs.writeFileSync(
+      path.join(outputPath, 'metrics-summary.json'),
+      JSON.stringify(this.metrics, null, 2)
+    );
+  }
+
+  // Helper methods
+  parseJUnitXml(xml) {
+    // Simplified XML parsing (in practice, would use xml2js or similar)
+    // This is a placeholder - actual implementation would use proper XML parser
+    return {
+      testsuites: [{
+        testcase: []
+      }]
+    };
+  }
+
+  countBy(array, fn) {
+    return array.reduce((acc, item) => {
+      const key = fn(item);
+      acc[key] = (acc[key] || 0) + 1;
+      return acc;
+    }, {});
+  }
+
+  calculateTrendData(items, period, dateExtractor) {
+    const trends = {};
+    
+    for (const item of items) {
+      const dateStr = dateExtractor(item);
+      trends[dateStr] = (trends[dateStr] || 0) + 1;
+    }
+    
+    // Convert to array and sort
+    return Object.entries(trends)
+      .map(([period, count]) => ({ period, count }))
+      .sort((a, b) => a.period.localeCompare(b.period));
+  }
+
+  getWeekString(date) {
+    const year = date.getFullYear();
+    const week = this.getWeekNumber(date);
+    return \
+{year}-W\
+{week.toString().padStart(2, '0')}\
+`;
+  }
+
+  getWeekNumber(date) {
+    const d = new Date(date);
+    d.setHours(0, 0, 0, 0);
+    d.setDate(d.getDate() + 4 - (d.getDay() || 7));
+    const yearStart = new Date(d.getFullYear(), 0, 1);
+    return Math.ceil((((d - yearStart) / 86400000) + 1) / 7);
+  }
+
+  getPercentile(values, percentile) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = (percentile / 100) * (sorted.length - 1);
+    const floor = Math.floor(index);
+    const ceil = Math.ceil(index);
+    
+    if (floor === ceil) {
+      return sorted[floor];
+    }
+    
+    return sorted[floor] + (sorted[ceil] - sorted[floor]) * (index - floor);
+  }
+
+  calculateLeadTime(deployments) {
+    // Calculate average time from commit to deployment
+    if (deployments.length === 0) return 0;
+    
+    // This is a simplified calculation - in practice would need commit timestamps
+    return 2; // Return 2 days as placeholder
+  }
+
+  calculateRollbackRate(deployments) {
+    // Calculate percentage of deployments that were rolled back
+    if (deployments.length === 0) return 0;
+    
+    // This is a simplified calculation - in practice would need deployment status
+    return 5; // Return 5% as placeholder
+  }
+}
+
+// Run the processor
+async function main() {
+  const processor = new MetricsProcessor();
+  await processor.processAllMetrics();
+}
+
+// Execute if run directly
+if (require.main === module) {
+  main().catch(console.error);
+}
+
+module.exports = MetricsProcessor;
+```
+
+### Dashboard Implementation
+
+```javascript
+// components/QualityDashboard.vue
+<template>
+  <div class="quality-dashboard">
+    <header class="dashboard-header">
+      <h1>Quality Metrics Dashboard</h1>
+      <div class="last-updated">
+        Last updated: {{ lastUpdated }}
+        <button @click="refresh" :disabled="isRefreshing">
+          {{ isRefreshing ? 'Refreshing...' : 'Refresh' }}
+        </button>
+      </div>
+    </header>
+
+    <div class="dashboard-layout">
+      <!-- KPI Summary -->
+      <section class="kpi-summary">
+        <div class="kpi-card" v-for="kpi in kpis" :key="kpi.id">
+          <h3>{{ kpi.name }}</h3>
+          <div class="kpi-value" :class="getStatusClass(kpi)">
+            {{ formatValue(kpi.value, kpi.format) }}
+            <trend-icon :value="kpi.trend" />
+          </div>
+          <div class="kpi-target">
+            Target: {{ formatValue(kpi.target, kpi.format) }}
+          </div>
+          <div class="kpi-status">
+            {{ kpi.status }}
+          </div>
+        </div>
+      </section>
+
+      <!-- Charts -->
+      <section class="charts">
+        <div class="chart-container">
+          <h2>Defect Trends</h2>
+          <line-chart :data="defectTrends" />\
+`
+        </div>
+
+        <div class="chart-container">
+          <h2>Test Coverage</h2>
+          <bar-chart :data="coverageData" />
+        </div>
+
+        <div class="chart-container">
+          <h2>Deployment Success Rate</h2>
+          <area-chart :data="deploymentSuccess" />
+        </div>
+
+        <div class="chart-container">
+          <h2>Performance Metrics</h2>
+          <gauge-chart 
+            title="Response Time" 
+            :value="performanceMetrics.responseTime" 
+            :max="500" 
+            unit="ms" />
+        </div>
+      </section>
+
+      <!-- Detailed Tables -->
+      <section class="detail-sections">
+        <div class="detail-table">
+          <h2>Recent Defects</h2>
+          <table>
+            <thead>
+              <tr>
+                <th>ID</th>
+                <th>Summary</th>
+                <th>Priority</th>
+                <th>Status</th>
+                <th>Age</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="defect in recentDefects" :key="defect.id">
+                <td>{{ defect.key }}</td>
+                <td>{{ truncate(defect.fields.summary, 50) }}</td>
+                <td :class="'priority-' + getPriorityClass(defect.fields.priority.name)">
+                  {{ defect.fields.priority.name }}
+                </td>
+                <td class="status">{{ defect.fields.status.name }}</td>
+                <td>{{ getAge(defect.fields.created) }}</td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+
+        <div class="detail-table">
+          <h2>Release Quality</h2>
+          <table>
+            <thead>
+              <tr>
+                <th>Release</th>
+                <th>Version</th>
+                <th>UAT Defects</th>
+                <th>P0/P1 in Prod</th>
+                <th>Quality Score</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="release in recentReleases" :key="release.date">
+                <td>{{ formatDate(release.date) }}</td>
+                <td>{{ release.version }}</td>
+                <td>{{ release.uatDefects }}</td>
+                <td :class="{ 'critical': release.p0p1InProd > 0 }">
+                  {{ release.p0p1InProd }}
+                </td>
+                <td :class="getQualityClass(release.qualityScore)">
+                  {{ release.qualityScore }}/10
+                </td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </section>
+
+      <!-- Action Items -->
+      <section class="action-items">
+        <h2>Action Items</h2>
+        <div class="action-list">
+          <div 
+            v-for="(item, index) in actionItems" 
+            :key="index" 
+            class="action-card"
+            :class="item.priority">
+            <div class="action-header">
+              <h3>{{ item.title }}</h3>
+              <span class="priority-badge" :class="item.priority">
+                {{ item.priority }}
+              </span>
+            </div>
+            <p class="owner">Owner: {{ item.owner }}</p>
+            <p class="due-date">Due: {{ formatDate(item.dueDate) }}</p>
+            <div class="action-status">
+              <progress :value="item.progress" max="100" />
+              <span>{{ item.progress }}%</span>
+            </div>
+          </div>
+        </div>
+      </section>
+    </div>
+  </div>
+</template>
+
+<script>
+import LineChart from './charts/LineChart.vue';
+import BarChart from './charts/BarChart.vue';
+import AreaChart from './charts/AreaChart.vue';
+import GaugeChart from './charts/GaugeChart.vue';
+import TrendIcon from './icons/TrendIcon.vue';
+
+export default {
+  name: 'QualityDashboard',
+  components: {
+    LineChart,
+    BarChart,
+    AreaChart,
+    GaugeChart,
+    TrendIcon
+  },
+  data() {
+    return {
+      lastUpdated: null,
+      isRefreshing: false,
+      kpis: [],
+      defectTrends: [],
+      coverageData: [],
+      deploymentSuccess: [],
+      performanceMetrics: {},
+      recentDefects: [],
+      recentReleases: [],
+      actionItems: []
+    };
+  },
+  created() {
+    this.fetchData();
+    // Refresh data every 15 minutes
+    this.refreshInterval = setInterval(this.refresh, 15 * 60 * 1000);
+  },
+  beforeDestroy() {
+    clearInterval(this.refreshInterval);
+  },
+  methods: {
+    async fetchData() {
+      this.isRefreshing = true;
+      try {
+        // Fetch all data from API
+        const [metrics, defects, releases, actions] = await Promise.all([
+          this.fetchMetrics(),
+          this.fetchRecentDefects(),
+          this.fetchRecentReleases(),
+          this.fetchActionItems()
+        ]);
+
+        // Update state
+        this.updateKpis(metrics.kpis);
+        this.updateCharts(metrics);
+        this.recentDefects = defects;
+        this.recentReleases = releases;
+        this.actionItems = actions;
+        this.lastUpdated = new Date().toLocaleString();
+        
+      } catch (error) {
+        console.error('Error fetching data:', error);
+        // Use cached data or show error state
+      } finally {
+        this.isRefreshing = false;
+      }
+    },
+    
+    async refresh() {
+      await this.fetchData();
+    },
+    
+    async fetchMetrics() {
+      const response = await fetch('/api/metrics/quality-dashboard.json');
+      return await response.json();
+    },
+    
+    async fetchRecentDefects() {
+      const response = await fetch('/api/defects?maxResults=10&orderBy=-created');
+      const data = await response.json();
+      return data.issues || [];
+    },
+    
+    async fetchRecentReleases() {
+      const response = await fetch('/api/releases?maxResults=5&orderBy=-date');
+      return await response.json();
+    },
+    
+    async fetchActionItems() {
+      const response = await fetch('/api/actions?status=active');
+      return await response.json();
+    },
+    
+    updateKpis(kpis) {
+      this.kpis = [
+        {
+          id: 'defect-density',
+          name: 'Defect Density',
+          value: kpis.defects?.density || 0,
+          target: 1.0,
+          format: 'decimal',
+          trend: kpis.defects?.trend || 0,
+          status: this.getKpiStatus(kpis.defects?.density || 0, 1.0)
+        },
+        {
+          id: 'test-coverage',
+          name: 'Test Coverage',
+          value: kpis.coverage?.overall || 0,
+          target: 90.0,
+          format: 'percent',
+          trend: kpis.coverage?.trend || 0,
+          status: this.getKpiStatus(kpis.coverage?.overall || 0, 90.0)
+        },
+        {
+          id: 'pipeline-success',
+          name: 'Pipeline Success',
+          value: kpis.ci_cd?.success_rate || 0,
+          target: 95.0,
+          format: 'percent',
+          trend: kpis.ci_cd?.trend || 0,
+          status: this.getKpiStatus(kpis.ci_cd?.success_rate || 0, 95.0)
+        },
+        {
+          id: 'deploy-frequency',
+          name: 'Deploy Frequency',
+          value: kpis.ci_cd?.deployment_frequency || 0,
+          target: 7.0,
+          format: 'decimal',
+          trend: kpis.ci_cd?.trend || 0,
+          status: this.getKpiStatus(kpis.ci_cd?.deployment_frequency || 0, 7.0)
+        },
+        {
+          id: 'lead-time',
+          name: 'Lead Time',
+          value: kpis.ci_cd?.lead_time || 0,
+          target: 2.0,
+          format: 'days',
+          trend: kpis.ci_cd?.trend || 0,
+          status: this.getKpiStatus(2.0, kpis.ci_cd?.lead_time || 0) // Inverse comparison
+        }
+      ];
+    },
+    
+    updateCharts(metrics) {
+      // Defect trends
+      this.defectTrends = {
+        labels: metrics.defects?.trends.map(t => t.period) || [],
+        datasets: [
+          {
+            label: 'Defects',
+            data: metrics.defects?.trends.map(t => t.count) || [],
+            borderColor: '#d62728',
+            backgroundColor: 'rgba(214, 39, 40, 0.1)'
+          }
+        ]
+      };
+
+      // Coverage data
+      this.coverageData = {
+        labels: ['Lines', 'Statements', 'Functions', 'Branches'],
+        datasets: [
+          {
+            label: 'Coverage',
+            data: [
+              metrics.coverage?.lines?.percentage || 0,
+              metrics.coverage?.statements?.percentage || 0,
+              metrics.coverage?.functions?.percentage || 0,
+              metrics.coverage?.branches?.percentage || 0
+            ],
+            backgroundColor: [
+              metrics.coverage?.lines?.percentage >= 90 ? '#2ca02c' : 
+              metrics.coverage?.lines?.percentage >= 80 ? '#ffbb78' : '#d62728',
+              
+              metrics.coverage?.statements?.percentage >= 90 ? '#2ca02c' : 
+              metrics.coverage?.statements?.percentage >= 80 ? '#ffbb78' : '#d62728',
+              
+              metrics.coverage?.functions?.percentage >= 90 ? '#2ca02c' : 
+              metrics.coverage?.functions?.percentage >= 80 ? '#ffbb78' : '#d62728',
+              
+              metrics.coverage?.branches?.percentage >= 90 ? '#2ca02c' : 
+              metrics.coverage?.branches?.percentage >= 80 ? '#ffbb78' : '#d62728'
+            ]
+          }
+        ]
+      };
+
+      // Deployment success
+      this.deploymentSuccess = {
+        labels: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'],
+        datasets: [
+          {
+            label: 'Success Rate',
+            data: [100, 100, 95, 100, 90, 100, 100],
+            fill: true,
+            borderColor: '#1f77b4',
+            backgroundColor: 'rgba(31, 119, 180, 0.2)'
+          }
+        ]
+      };
+
+      // Performance metrics
+      this.performanceMetrics = {
+        responseTime: metrics.performance?.response_time?.p95 || 250,
+        errorRate: metrics.performance?.error_rate?.average || 0.5,
+        throughput: metrics.performance?.throughput?.average || 1200
+      };
+    },
+    
+    getKpiStatus(value, target) {
+      // For most KPIs, higher is better
+      if (value >= target) {
+        return 'On Target';
+      } else if (value >= target * 0.9) {
+        return 'Near Target';
+      } else {
+        return 'Off Target';
+      }
+    },
+    
+    getStatusClass(kpi) {
+      if (kpi.value >= kpi.target) {
+        return 'good';
+      } else if (kpi.value >= kpi.target * 0.9) {
+        return 'warning';
+      } else {
+        return 'bad';
+      }
+    },
+    
+    formatValue(value, format) {
+      switch (format) {
+        case 'percent':
+          return `${value.toFixed(1)}%`;
+        case 'decimal':
+          return value.toFixed(2);
+        case 'days':
+          return `${value.toFixed(1)}d`;
+        default:
+          return value.toString();
+      }
+    },
+    
+    getPriorityClass(priority) {
+      switch (priority?.toLowerCase()) {
+        case 'critical': return 'critical';
+        case 'high': return 'high';
+        case 'medium': return 'medium';
+        case 'low': return 'low';
+        default: return 'low';
+      }
+    },
+    
+    getQualityClass(score) {
+      if (score >= 8) return 'good';
+      if (score >= 6) return 'warning';
+      return 'bad';
+    },
+    
+    getAge(dateString) {
+      const date = new Date(dateString);
+      const now = new Date();
+      const diffTime = Math.abs(now - date);
+      const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+      return \
+{diffDays}d\
+`;
+    },
+    
+    formatDate(dateString) {
+      return new Date(dateString).toLocaleDateString();
+    },
+    
+    truncate(text, length) {
+      if (text.length <= length) return text;
+      return text.substr(0, length) + '...';
+    }
+  }
+};
+</script>
+
+<style scoped>
+.quality-dashboard {
+  font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+  max-width: 1600px;
+  margin: 0 auto;
+  padding: 20px;
+}
+
+dashboard-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 20px;
+  padding-bottom: 10px;
+  border-bottom: 1px solid #e0e0e0;
+}
+
+dashboard-header h1 {
+  margin: 0;
+  color: #333;
+}
+
+.last-updated {
+  display: flex;
+  align-items: center;
+  color: #666;
+  font-size: 14px;
+}
+
+.last-updated button {
+  margin-left: 10px;
+  padding: 5px 10px;
+  background: #f0f0f0;
+  border: 1px solid #ddd;
+  border-radius: 3px;
+  cursor: pointer;
+}
+
+.last-updated button:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+dashboard-layout {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 20px;
+}
+
+@media (min-width: 1200px) {
+  .dashboard-layout {
+    grid-template-columns: 2fr 1fr;
+  }
+}
+
+/* KPI Summary */
+kpi-summary {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+  gap: 15px;
+}
+
+.kpi-card {
+  background: white;
+  border: 1px solid #e0e0e0;
+  border-radius: 8px;
+  padding: 15px;
+  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.kpi-card h3 {
+  margin: 0 0 10px 0;
+  color: #333;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.kpi-value {
+  font-size: 24px;
+  font-weight: bold;
+  margin-bottom: 5px;
+}
+
+.kpi-value.good {
+  color: #2ca02c;
+}
+
+.kpi-value.warning {
+  color: #ff7f0e;
+}
+
+.kpi-value.bad {
+  color: #d62728;
+}
+
+.kpi-target {
+  color: #666;
+  font-size: 14px;
+  margin-bottom: 5px;
+}
+
+.kpi-status {
+  font-size: 12px;
+  padding: 2px 6px;
+  border-radius: 3px;
+  display: inline-block;
+}
+
+.kpi-status.On\ Target {
+  background: #2ca02c;
+  color: white;
+}
+
+.kpi-status.Near\ Target {
+  background: #ff7f0e;
+  color: white;
+}
+
+.kpi-status.Off\ Target {
+  background: #d62728;
+  color: white;
+}
+
+/* Charts */
+charts {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 20px;
+}
+
+@media (min-width: 1200px) {
+  .charts {
+    grid-column: 1;
+    grid-template-columns: 1fr 1fr;
+  }
+}
+
+.chart-container {
+  background: white;
+  border: 1px solid #e0e0e0;
+  border-radius: 8px;
+  padding: 20px;
+  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.chart-container h2 {
+  margin: 0 0 15px 0;
+  color: #333;
+  font-size: 18px;
+}
+
+/* Detail Sections */
+detail-sections {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 20px;
+}
+
+@media (min-width: 1200px) {
+  .detail-sections {
+    grid-column: 1;
+  }
+}
+
+.detail-table {
+  background: white;
+  border: 1px solid #e0e0e0;
+  border-radius: 8px;
+  padding: 20px;
+  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.detail-table h2 {
+  margin: 0 0 15px 0;
+  color: #333;
+  font-size: 18px;
+}
+
+.detail-table table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.detail-table th {
+  text-align: left;
+  padding: 10px;
+  background: #f8f9fa;
+  border-bottom: 2px solid #e0e0e0;
+  font-weight: 600;
+  color: #333;
+}
+
+.detail-table td {
+  padding: 10px;
+  border-bottom: 1px solid #e0e0e0;
+}
+
+.detail-table tr:last-child td {
+  border-bottom: none;
+}
+
+.detail-table .priority-critical {
+  color: #d62728;
+  font-weight: bold;
+}
+
+.detail-table .priority-high {
+  color: #ff7f0e;
+}
+
+.detail-table .priority-medium {
+  color: #ffbb78;
+}
+
+.detail-table .status {
+  font-weight: 500;
+}
+
+.detail-table .critical {
+  color: #d62728;
+  font-weight: bold;
+}
+
+/* Action Items */
+action-items {
+  background: white;
+  border: 1px solid #e0e0e0;
+  border-radius: 8px;
+  padding: 20px;
+  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.action-items h2 {
+  margin: 0 0 15px 0;
+  color: #333;
+  font-size: 18px;
+}
+
+.action-list {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 15px;
+}
+
+@media (min-width: 768px) {
+  .action-list {
+    grid-template-columns: 1fr 1fr;
+  }
+}
+
+@media (min-width: 1200px) {
+  .action-list {
+    grid-template-columns: 1fr;
+  }
+  .action-items {
+    grid-column: 2;
+    grid-row: 1 / 4;
+  }
+}
+
+.action-card {
+  border: 1px solid #e0e0e0;
+  border-radius: 8px;
+  padding: 15px;
+}
+
+.action-card.high {
+  border-left: 4px solid #ff7f0e;
+}
+
+.action-card.critical {
+  border-left: 4px solid #d62728;
+}
+
+.action-card.low {
+  border-left: 4px solid #2ca02c;
+}
+
+.action-header {
+  display: flex;
+  justify-content: space-between;
+  margin-bottom: 10px;
+}
+
+.action-header h3 {
+  margin: 0;
+  color: #333;
+  font-size: 16px;
+}
+
+.priority-badge {
+  padding: 3px 8px;
+  border-radius: 3px;
+  font-size: 12px;
+  font-weight: bold;
+  color: white;
+}
+
+.priority-badge.critical {
+  background: #d62728;
+}
+
+.priority-badge.high {
+  background: #ff7f0e;
+}
+
+.priority-badge.low {
+  background: #2ca02c;
+}
+
+.owner, .due-date {
+  color: #666;
+  font-size: 14px;
+  margin: 5px 0;
+}
+
+.action-status {
+  display: flex;
+  align-items: center;
+  margin-top: 10px;
+}
+
+.action-status progress {
+  flex-grow: 1;
+  height: 10px;
+  border: none;
+}
+
+.action-status span {
+  margin-left: 10px;
+  font-size: 14px;
+  color: #666;
+}
+</style>
+```
diff --git a/Claude/skills/test-automation.md b/Claude/skills/test-automation.md
new file mode 100644
index 0000000..738b362
--- /dev/null
+++ b/Claude/skills/test-automation.md
@@ -0,0 +1,234 @@
+---
+type: skill
+name: test-automation
+description: Test automation framework development, scripting, integration, maintenance, and best practices across multiple technologies.
+origin: ECC
+---
+
+# Test Automation Framework
+
+Comprehensive guide to developing and maintaining robust test automation frameworks for various technology stacks.
+
+## Framework Architecture
+
+### Layered Design
+
+```
+test-automation/
+├── framework/
+│   ├── drivers/
+│   │   ├── web-driver.js
+│   │   ├── api-client.js
+│   │   └── mobile-driver.js
+│   ├── utils/
+│   │   ├── reporter.js
+│   │   ├── retry.js
+│   │   └── screenshot.js
+│   ├── assertions/
+│   │   ├── base-assertions.js
+│   │   └── custom-assertions.js
+│   └── config/
+│       ├── default.js
+│       ├── ci.js
+│       └── local.js
+├── tests/
+│   ├── unit/
+│   ├── integration/
+│   └── e2e/
+├── page-objects/
+├── fixtures/
+└── scripts/
+    ├── setup.js
+    └── cleanup.js
+```
+
+### Core Components
+
+**Test Runner Integration**:
+```javascript
+// Example: Jest custom environment
+const PlaywrightEnvironment = require('@playwright/test/lib/integration').PlaywrightTestEnvironment;
+
+class CustomTestEnvironment extends PlaywrightEnvironment {
+  async setup() {
+    await super.setup();
+    this.global.page = this.playwright._getOrCreateBrowser().newPage();
+    this.global.api = new APIClient(process.env.API_BASE_URL);
+  }
+
+  async teardown() {
+    await this.global.page.close();
+    await super.teardown();
+  }
+}
+
+module.exports = CustomTestEnvironment;
+```
+
+**Configuration Management**:
+```javascript
+// config/default.js
+module.exports = {
+  baseUrl: 'https://staging.example.com',
+  timeout: 30000,
+  retryAttempts: 3,
+  headless: true,
+  screenshotOnFailure: true,
+  reporters: ['spec', 'junit', 'allure'],
+  environments: {
+    development: { baseUrl: 'http://localhost:3000' },
+    staging: { baseUrl: 'https://staging.example.com' },
+    production: { baseUrl: 'https://example.com' }
+  }
+};
+```
+
+## Automation Patterns
+
+### Page Object Model (POM)
+
+```javascript
+// page-objects/login.page.js
+class LoginPage {
+  constructor(page) {
+    this.page = page;
+    this.usernameInput = page.locator('#username');
+    this.passwordInput = page.locator('#password');
+    this.loginButton = page.locator('[data-testid="login-btn"]');
+    this.errorMessage = page.locator('[data-testid="error-message"]');
+  }
+
+  async navigate() {
+    await this.page.goto('/login');
+  }
+
+  async login(username, password) {
+    await this.usernameInput.fill(username);
+    await this.passwordInput.fill(password);
+    await this.loginButton.click();
+  }
+
+  async getErrorMessage() {
+    return await this.errorMessage.textContent();
+  }
+}
+
+module.exports = LoginPage;
+```
+
+### Component Object Model
+
+```javascript
+// components/header.component.js
+class HeaderComponent {
+  constructor(page) {
+    this.page = page;
+    this.logo = page.locator('[data-testid="logo"]');
+    this.userMenu = page.locator('[data-testid="user-menu"]');
+    this.notifications = page.locator('[data-testid="notifications"]');
+  }
+
+  async verifyHeaderVisible() {
+    await expect(this.logo).toBeVisible();
+    await expect(this.userMenu).toBeVisible();
+  }
+
+  async navigateToProfile() {
+    await this.userMenu.click();
+    await this.page.locator('[data-testid="profile-link"]').click();
+  }
+}
+
+module.exports = HeaderComponent;
+```
+
+### Screenplay Pattern
+
+```javascript
+// actors/user.actor.js
+class User {
+  constructor(name) {
+    this.name = name;
+    this.tasks = [];
+    this.questions = [];
+  }
+
+  async attemptsTo(...tasks) {
+    for (const task of tasks) {
+      await task.performAs(this);
+    }
+  }
+
+  async asks(...questions) {
+    return await Promise.all(questions.map(q => q.answeredBy(this)));
+  }
+}
+
+// tasks/login.task.js
+class Login {
+  constructor(username, password) {
+    this.username = username;
+    this.password = password;
+  }
+
+  async performAs(actor) {
+    const loginPage = new LoginPage(actor.page);
+    await loginPage.navigate();
+    await loginPage.login(this.username, this.password);
+  }
+}
+```
+
+## CI/CD Integration
+
+### Pipeline Configuration
+
+```yaml
+# .github/workflows/test-automation.yml
+name: Test Automation
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18.x]
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Install Playwright browsers
+      run: npx playwright install --with-deps
+
+    - name: Run tests
+      run: npm run test:automation
+      env:
+        BASE_URL: ${{ secrets.STAGING_URL }}
+        HEADLESS: true
+
+    - name: Upload test results
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: test-results
+        path: |
+          test-results/
+          screenshots/
+          videos/
+        retention-days: 30
+```
\ No newline at end of file
diff --git a/Claude/skills/test-data-strategy.md b/Claude/skills/test-data-strategy.md
new file mode 100644
index 0000000..a06fb24
--- /dev/null
+++ b/Claude/skills/test-data-strategy.md
@@ -0,0 +1,1509 @@
+---
+type: skill
+name: test-data-strategy
+description: Comprehensive framework for test data management including provisioning, anonymization, synthetic data generation, and lifecycle management.
+origin: ECC
+---
+
+# Test Data Strategy Framework
+
+Strategic approach to managing test data across the development lifecycle, ensuring data quality, privacy compliance, and test reliability.
+
+## Data Provisioning Patterns
+
+### Synthetic Data Generation
+
+```python
+# utils/synthetic_data.py
+import random
+import string
+from datetime import datetime, timedelta
+from typing import Dict, List, Any
+import pandas as pd
+import numpy as np
+
+class SyntheticDataGenerator:
+    """Generate realistic synthetic data for testing"""
+    
+    def __init__(self):
+        self.first_names = ['James', 'Mary', 'John', 'Patricia', 'Robert', 'Jennifer']
+        self.last_names = ['Smith', 'Johnson', 'Williams', 'Jones', 'Brown', 'Davis']
+        self.domains = ['example.com', 'test.org', 'demo.net', 'qa.co']
+        
+    def generate_email(self, first_name: str = None, last_name: str = None) -> str:
+        """Generate realistic email address"""
+        if not first_name:
+            first_name = random.choice(self.first_names)
+        if not last_name:
+            last_name = random.choice(self.last_names)
+            
+        separator = random.choice(['.', '_', ''])
+        domain = random.choice(self.domains)
+        
+        # Create variation in email format
+        variations = [
+            f"{first_name.lower()}{separator}{last_name.lower()}@{domain}",
+            f"{first_name[0].lower()}{last_name.lower()}@{domain}",
+            f"{first_name.lower()}{random.randint(10,99)}@{domain}"
+        ]
+        
+        return random.choice(variations)
+    
+    def generate_phone(self) -> str:
+        """Generate realistic phone number"""
+        return f"+1-{random.randint(200,999)}-{random.randint(100,999)}-{random.randint(1000,9999)}"
+    
+    def generate_address(self) -> Dict[str, str]:
+        """Generate realistic address"""
+        streets = ['Main St', 'Oak Ave', 'Pine Rd', 'Maple Dr', 'Cedar Ln']
+        cities = ['Springfield', 'Greenville', 'Oakland', 'Portsmouth', 'Lakeside']
+        states = ['CA', 'TX', 'NY', 'FL', 'WA']
+        
+        return {
+            'street': f"{random.randint(100,999)} {random.choice(streets)}",
+            'city': random.choice(cities),
+            'state': random.choice(states),
+            'zip_code': f"{random.randint(10000,99999)}"
+        }
+    
+    def generate_user(self, user_type: str = 'standard') -> Dict[str, Any]:
+        """Generate complete user profile"""
+        first_name = random.choice(self.first_names)
+        last_name = random.choice(self.last_names)
+        
+        user = {
+            'first_name': first_name,
+            'last_name': last_name,
+            'email': self.generate_email(first_name, last_name),
+            'phone': self.generate_phone(),
+            'date_of_birth': (datetime.now() - timedelta(
+                days=random.randint(365*18, 365*80)
+            )).strftime('%Y-%m-%d'),
+            'created_at': datetime.now().isoformat(),
+            'updated_at': datetime.now().isoformat()
+        }
+        
+        # Add user type specific attributes
+        if user_type == 'premium':
+            user.update({
+                'membership_level': 'premium',
+                'membership_since': (datetime.now() - timedelta(
+                    days=random.randint(30, 365*3)
+                )).strftime('%Y-%m-%d'),
+                'loyalty_points': random.randint(100, 10000)
+            })
+        elif user_type == 'business':
+            user.update({
+                'company_name': f"{random.choice(['Tech', 'Global', 'Innovate', 'Solutions'])} {random.choice(['Inc', 'LLC', 'Co'])}",
+                'business_type': random.choice(['corporation', 'llc', 'partnership']),
+                'tax_id': f"{random.randint(10,99)}-{random.randint(1000000,9999999)}"
+            })
+        
+        return user
+    
+    def generate_order(self, user_id: str, status: str = None) -> Dict[str, Any]:
+        """Generate realistic order data"""
+        products = [
+            {'name': 'Premium Subscription', 'price': 99.99, 'category': 'software'},
+            {'name': 'Enterprise License', 'price': 499.99, 'category': 'software'},
+            {'name': 'Training Course', 'price': 299.99, 'category': 'education'},
+            {'name': 'Consulting Package', 'price': 1999.99, 'category': 'services'}
+        ]
+        
+        # Random number of items (1-5)
+        num_items = random.randint(1, 5)
+        items = []
+        total = 0.0
+        
+        for _ in range(num_items):
+            product = random.choice(products)
+            quantity = random.randint(1, 3)
+            line_total = product['price'] * quantity
+            total += line_total
+            
+            items.append({
+                'product_id': f"PROD{random.randint(1000,9999)}",
+                'name': product['name'],
+                'quantity': quantity,
+                'unit_price': product['price'],
+                'line_total': round(line_total, 2)
+            })
+        
+        # Randomize status if not provided
+        if not status:
+            status = random.choices(
+                ['pending', 'confirmed', 'shipped', 'delivered', 'cancelled'],
+                weights=[10, 40, 30, 15, 5]
+            )[0]
+        
+        return {
+            'order_id': f"ORD{datetime.now().strftime('%Y%m')}{random.randint(1000,9999)}",
+            'user_id': user_id,
+            'items': items,
+            'total_amount': round(total, 2),
+            'currency': 'USD',
+            'status': status,
+            'created_at': (datetime.now() - timedelta(
+                hours=random.randint(0, 72),
+                minutes=random.randint(0, 59)
+            )).isoformat(),
+            'updated_at': datetime.now().isoformat()
+        }
+    
+    def generate_data_frame(self, schema: Dict[str, str], count: int) -> pd.DataFrame:
+        """Generate pandas DataFrame with specified schema"""
+        data = {}
+        
+        for field, field_type in schema.items():
+            if field_type == 'string':
+                data[field] = [self._generate_random_string() for _ in range(count)]
+            elif field_type == 'email':
+                data[field] = [self.generate_email() for _ in range(count)]
+            elif field_type == 'phone':
+                data[field] = [self.generate_phone() for _ in range(count)]
+            elif field_type == 'integer':
+                data[field] = [random.randint(1, 1000) for _ in range(count)]
+            elif field_type == 'float':
+                data[field] = [round(random.uniform(1.0, 1000.0), 2) for _ in range(count)]
+            elif field_type == 'date':
+                start_date = datetime.now() - timedelta(days=365)
+                data[field] = [
+                    (start_date + timedelta(days=random.randint(0, 365))).strftime('%Y-%m-%d')
+                    for _ in range(count)
+                ]
+            elif field_type == 'boolean':
+                data[field] = [random.choice([True, False]) for _ in range(count)]
+            
+        return pd.DataFrame(data)
+    
+    def _generate_random_string(self, length: int = 8) -> str:
+        """Generate random string of specified length"""
+        return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
+
+# Usage example
+if __name__ == "__main__":
+    generator = SyntheticDataGenerator()
+    
+    # Generate 100 users
+    users = [generator.generate_user('standard') for _ in range(100)]
+    users += [generator.generate_user('premium') for _ in range(20)]
+    users += [generator.generate_user('business') for _ in range(10)]
+    
+    # Generate orders for users
+    orders = []
+    for user in users:
+        # Each user has 0-3 orders
+        num_orders = random.randint(0, 3)
+        for _ in range(num_orders):
+            orders.append(generator.generate_order(user['email']))
+    
+    print(f"Generated {len(users)} users and {len(orders)} orders")
+```
+
+### Data Masking and Anonymization
+
+```python
+# utils/data_anonymizer.py
+import re
+import hashlib
+from typing import Dict, Any, List
+import pandas as pd
+
+class DataAnonymizer:
+    """Anonymize sensitive data for testing purposes"""
+    
+    def __init__(self, salt: str = "test_salt"):
+        self.salt = salt
+        
+    def anonymize_email(self, email: str) -> str:
+        """Hash email address while preserving domain"""
+        if not email or '@' not in email:
+            return email
+            
+        local_part, domain = email.split('@')
+        # Hash the local part and append domain
+        hashed = hashlib.sha256(f"{local_part}{self.salt}".encode()).hexdigest()[:8]
+        return f"anon_{hashed}@{domain}"
+    
+    def anonymize_phone(self, phone: str) -> str:
+        """Mask phone number, preserve country code and last 4 digits"""
+        if not phone:
+            return phone
+            
+        # Extract digits
+        digits = re.sub(r'\D', '', phone)
+        
+        if len(digits) == 10:  # US number
+            return f"+1-XXX-XXX-{digits[-4:] }"
+        elif len(digits) > 10:
+            country_code = digits[:-10]
+            return f"+{country_code}-XXX-XXX-{digits[-4:] }"
+        else:
+            return "+X-XXX-XXX-XXXX"  # Generic mask
+    
+    def anonymize_address(self, address: Dict[str, str]) -> Dict[str, str]:
+        """Anonymize address information"""
+        if not address:
+            return address
+            
+        # Keep city and state but randomize street and zip
+        return {
+            'street': f"{random.randint(100, 999)} Main St",
+            'city': address.get('city', 'City'),
+            'state': address.get('state', 'ST'),
+            'zip_code': f"{random.randint(10000, 99999)}"
+        }
+    
+    def anonymize_name(self, first_name: str, last_name: str) -> Dict[str, str]:
+        """Anonymize person name"""
+        # Use consistent hashing for same names
+        first_hash = hashlib.md5(f"{first_name}{self.salt}".encode()).hexdigest()[0]
+        last_hash = hashlib.md5(f"{last_name}{self.salt}".encode()).hexdigest()[0]
+        
+        # Map to generic names based on hash
+        first_names = ['User', 'Client', 'Customer', 'Member', 'Account']
+        last_names = ['One', 'Two', 'Three', 'Four', 'Five']
+        
+        return {
+            'first_name': first_names[ord(first_hash) % len(first_names)],
+            'last_name': last_names[ord(last_hash) % len(last_names)]
+        }
+    
+    def anonymize_user(self, user: Dict[str, Any]) -> Dict[str, Any]:
+        """Anonymize complete user profile"""
+        if not user:
+            return user
+            
+        # Create deep copy
+        anonymized = user.copy()
+        
+        # Anonymize sensitive fields
+        if 'email' in anonymized:
+            anonymized['email'] = self.anonymize_email(anonymized['email'])
+            
+        if 'phone' in anonymized:
+            anonymized['phone'] = self.anonymize_phone(anonymized['phone'])
+            
+        if 'first_name' in anonymized and 'last_name' in anonymized:
+            names = self.anonymize_name(anonymized['first_name'], anonymized['last_name'])
+            anonymized['first_name'] = names['first_name']
+            anonymized['last_name'] = names['last_name']
+            
+        if 'address' in anonymized:
+            anonymized['address'] = self.anonymize_address(anonymized['address'])
+            
+        # Remove or mask other sensitive fields
+        sensitive_fields = ['ssn', 'national_id', 'credit_card', 'bank_account']
+        for field in sensitive_fields:
+            if field in anonymized:
+                anonymized[field] = 'REDACTED'
+                
+        # Add anonymization metadata
+        anonymized['anonymized_at'] = datetime.now().isoformat()
+        anonymized['original_user_id'] = anonymized.get('user_id')
+        anonymized['user_id'] = f"ANON_{hashlib.md5(f"{anonymized.get('email', '')}{self.salt}".encode()).hexdigest()[:12]}"
+        
+        return anonymized
+    
+    def anonymize_dataset(self, df: pd.DataFrame, config: Dict[str, str]) -> pd.DataFrame:
+        """Anonymize pandas DataFrame according to configuration"""
+        df_anon = df.copy()
+        
+        for column, method in config.items():
+            if column not in df_anon.columns:
+                continue
+                
+            if method == 'email':
+                df_anon[column] = df_anon[column].apply(self.anonymize_email)
+            elif method == 'phone':
+                df_anon[column] = df_anon[column].apply(self.anonymize_phone)
+            elif method == 'name':
+                # For name columns, we need to handle first and last separately
+                if 'first' in column.lower():
+                    df_anon[column] = df_anon.apply(
+                        lambda row: self.anonymize_name(row[column], row.get(column.replace('first', 'last'), ''))['first_name'], 
+                        axis=1
+                    )
+                elif 'last' in column.lower():
+                    df_anon[column] = df_anon.apply(
+                        lambda row: self.anonymize_name(row.get(column.replace('last', 'first'), ''), row[column])['last_name'], 
+                        axis=1
+                    )
+            elif method == 'address':
+                # For address, we assume a JSON/Dict column
+                df_anon[column] = df_anon[column].apply(self.anonymize_address)
+            elif method == 'id':
+                # For IDs, hash them
+                df_anon[column] = df_anon[column].apply(
+                    lambda x: f"ANON_{hashlib.md5(f"{x}{self.salt}".encode()).hexdigest()[:8]}" if pd.notna(x) else x
+                )
+            
+        return df_anon
+    
+    def generate_test_subset(self, source_data: List[Dict[str, Any]], target_count: int, 
+                           distribution: Dict[str, float] = None) -> List[Dict[str, Any]]:
+        """Generate representative test subset from production data"""
+        if distribution:
+            # Stratified sampling based on distribution
+            result = []
+            for category, ratio in distribution.items():
+                category_items = [item for item in source_data if item.get('category') == category]
+                sample_count = int(target_count * ratio)
+                result.extend(random.sample(category_items, min(sample_count, len(category_items))))
+            return result
+        else:
+            # Random sampling
+            return random.sample(source_data, min(target_count, len(source_data)))
+
+# Usage example
+if __name__ == "__main__":
+    anonymizer = DataAnonymizer(salt="my_secret_salt")
+    
+    # Example user data
+    user_data = {
+        'user_id': 'USR12345',
+        'first_name': 'John',
+        'last_name': 'Smith',
+        'email': 'john.smith@example.com',
+        'phone': '+1-555-123-4567',
+        'address': {
+            'street': '123 Main St',
+            'city': 'Springfield',
+            'state': 'IL',
+            'zip_code': '62701'
+        },
+        'ssn': '123-45-6789',
+        'created_at': '2025-01-15T10:30:00Z'
+    }
+    
+    anonymized_user = anonymizer.anonymize_user(user_data)
+    print("Original:", user_data)
+    print("Anonymized:", anonymized_user)
+```
+
+## Data Lifecycle Management
+
+### Test Data Factory Pattern
+
+```typescript
+// factories/user.factory.ts
+import { User, UserRole, UserStatus } from '../interfaces/user.interface';
+import { faker } from '@faker-js/faker';
+
+class UserFactory {
+  // Default attributes
+  private defaults = {
+    role: UserRole.USER,
+    status: UserStatus.ACTIVE,
+    email_verified: false,
+    created_at: new Date(),
+    updated_at: new Date()
+  };
+
+  /**
+   * Create a single user with optional overrides
+   */
+  public create(overrides: Partial<User> = {}): User {
+    const user: User = {
+      id: overrides.id || `user_${faker.string.uuid()}`,
+      first_name: overrides.first_name || faker.person.firstName(),
+      last_name: overrides.last_name || faker.person.lastName(),
+      email: overrides.email || faker.internet.email(),
+      role: overrides.role || this.defaults.role,
+      status: overrides.status || this.defaults.status,
+      email_verified: overrides.email_verified ?? this.defaults.email_verified,
+      created_at: overrides.created_at || this.defaults.created_at,
+      updated_at: overrides.updated_at || this.defaults.updated_at
+    };
+
+    // Apply specific scenarios
+    if (overrides.scenario === 'verified') {
+      user.email_verified = true;
+    }
+
+    if (overrides.scenario === 'admin') {
+      user.role = UserRole.ADMIN;
+    }
+
+    return user;
+  }
+
+  /**
+   * Create multiple users with the same attributes
+   */
+  public createMany(count: number, overrides: Partial<User> = {}): User[] {
+    return Array.from({ length: count }, () => this.create(overrides));
+  }
+
+  /**
+   * Create users with specific roles
+   */
+  public createAdmins(count: number = 1): User[] {
+    return this.createMany(count, { 
+      role: UserRole.ADMIN,
+      scenario: 'admin' 
+    });
+  }
+
+  public createModerators(count: number = 1): User[] {
+    return this.createMany(count, { role: UserRole.MODERATOR });
+  }
+
+  public createUsers(count: number = 1): User[] {
+    return this.createMany(count, { role: UserRole.USER });
+  }
+
+  /**
+   * Create users with specific statuses
+   */
+  public createActiveUsers(count: number = 1): User[] {
+    return this.createMany(count, { status: UserStatus.ACTIVE });
+  }
+
+  public createInactiveUsers(count: number = 1): User[] {
+    return this.createMany(count, { status: UserStatus.INACTIVE });
+  }
+
+  public createPendingUsers(count: number = 1): User[] {
+    return this.createMany(count, { status: UserStatus.PENDING });
+  }
+
+  /**
+   * Create verified users
+   */
+  public createVerifiedUsers(count: number = 1): User[] {
+    return this.createMany(count, { 
+      email_verified: true,
+      scenario: 'verified' 
+    });
+  }
+
+  /**
+   * Create users from specific regions
+   */
+  public createFromRegion(region: string, count: number = 1): User[] {
+    const users = this.createMany(count);
+    // In a real implementation, you might integrate with location data
+    return users;
+  }
+
+  /**
+   * Create users with specific attribute patterns
+   */
+  public createWithPattern(pattern: 'long-names' | 'short-names' | 'common-names', count: number = 1): User[] {
+    const users: User[] = [];
+    
+    for (let i = 0; i < count; i++) {
+      let firstName: string, lastName: string;
+      
+      switch (pattern) {
+        case 'long-names':
+          firstName = this.generateLongName();
+          lastName = this.generateLongName();
+          break;
+        case 'short-names':
+          firstName = this.generateShortName();
+          lastName = this.generateShortName();
+          break;
+        case 'common-names':
+        default:
+          firstName = faker.person.commonFirstName();
+          lastName = faker.person.commonLastName();
+      }
+      
+      users.push(this.create({ firstName, lastName }));
+    }
+    
+    return users;
+  }
+
+  private generateLongName(): string {
+    // Generate longer names (8-15 characters)
+    const length = faker.number.int({ min: 8, max: 15 });
+    return faker.string.alpha({ length, casing: 'title' });
+  }
+
+  private generateShortName(): string {
+    // Generate shorter names (2-4 characters)
+    const length = faker.number.int({ min: 2, max: 4 });
+    return faker.string.alpha({ length, casing: 'title' });
+  }
+}
+
+// Export singleton instance
+export const userFactory = new UserFactory();
+
+// Usage examples
+/*
+import { userFactory } from './factories/user.factory';
+
+// Create single user
+const user = userFactory.create();
+const admin = userFactory.create({ role: UserRole.ADMIN });
+
+// Create multiple users
+const users = userFactory.createMany(10);
+const activeUsers = userFactory.createActiveUsers(5);
+
+// Create specific scenarios
+const verifiedUsers = userFactory.createVerifiedUsers(3);
+const longNameUsers = userFactory.createWithPattern('long-names', 2);
+*/
+```
+
+```typescript
+// factories/order.factory.ts
+import { Order, OrderItem, OrderStatus } from '../interfaces/order.interface';
+import { Product } from '../interfaces/product.interface';
+import { userFactory } from './user.factory';
+import { faker } from '@faker-js/faker';
+
+class OrderFactory {
+  private defaults = {
+    status: OrderStatus.PENDING,
+    currency: 'USD',
+    created_at: new Date(),
+    updated_at: new Date()
+  };
+
+  // Predefined products for consistent test data
+  private products: Product[] = [
+    { 
+      id: 'prod-software', 
+      name: 'Software Subscription', 
+      price: 99.99, 
+      category: 'software' 
+    },
+    { 
+      id: 'prod-hardware', 
+      name: 'Hardware Device', 
+      price: 299.99, 
+      category: 'hardware' 
+    },
+    { 
+      id: 'prod-service', 
+      name: 'Consulting Service', 
+      price: 499.99, 
+      category: 'service' 
+    }
+  ];
+
+  /**
+   * Create a single order with optional overrides
+   */
+  public create(overrides: Partial<Order> = {}): Order {
+    // Get or create user
+    const userId = overrides.user_id || userFactory.create().id;
+    
+    // Create order items
+    const items = this.createOrderItems(overrides.items_count || 1);
+    
+    // Calculate total
+    const total = items.reduce((sum, item) => sum + item.line_total, 0);
+
+    const order: Order = {
+      id: overrides.id || `order_${faker.string.uuid()}`,
+      user_id: userId,
+      items: overrides.items || items,
+      total_amount: overrides.total_amount || total,
+      currency: overrides.currency || this.defaults.currency,
+      status: overrides.status || this.defaults.status,
+      created_at: overrides.created_at || this.defaults.created_at,
+      updated_at: overrides.updated_at || this.defaults.updated_at
+    };
+
+    // Apply scenarios
+    if (overrides.scenario === 'high-value') {
+      order.total_amount = faker.number.float({ min: 1000, max: 5000, precision: 2 });
+    }
+
+    if (overrides.scenario === 'international') {
+      order.currency = this.getRandomCurrency();
+    }
+
+    return order;
+  }
+
+  /**
+   * Create multiple orders
+   */
+  public createMany(count: number, overrides: Partial<Order> = {}): Order[] {
+    return Array.from({ length: count }, () => this.create(overrides));
+  }
+
+  /**
+   * Create orders with specific statuses
+   */
+  public createPendingOrders(count: number = 1): Order[] {
+    return this.createMany(count, { status: OrderStatus.PENDING });
+  }
+
+  public createConfirmedOrders(count: number = 1): Order[] {
+    return this.createMany(count, { status: OrderStatus.CONFIRMED });
+  }
+
+  public createShippedOrders(count: number = 1): Order[] {
+    return this.createMany(count, { status: OrderStatus.SHIPPED });
+  }
+
+  public createDeliveredOrders(count: number = 1): Order[] {
+    return this.createMany(count, { status: OrderStatus.DELIVERED });
+  }
+
+  public createCancelledOrders(count: number = 1): Order[] {
+    return this.createMany(count, { status: OrderStatus.CANCELLED });
+  }
+
+  /**
+   * Create high-value orders
+   */
+  public createHighValueOrders(count: number = 1): Order[] {
+    return this.createMany(count, { 
+      scenario: 'high-value',
+      status: OrderStatus.CONFIRMED 
+    });
+  }
+
+  /**
+   * Create international orders
+   */
+  public createInternationalOrders(count: number = 1): Order[] {
+    return this.createMany(count, { 
+      scenario: 'international',
+      status: OrderStatus.CONFIRMED 
+    });
+  }
+
+  /**
+   * Create orders for specific users
+   */
+  public createForUser(userId: string, count: number = 1): Order[] {
+    return this.createMany(count, { user_id: userId });
+  }
+
+  /**
+   * Create orders with specific item counts
+   */
+  public createWithItemCount(itemCount: number, count: number = 1): Order[] {
+    return this.createMany(count, { items_count: itemCount });
+  }
+
+  /**
+   * Create orders from specific categories
+   */
+  public createFromCategory(category: string, count: number = 1): Order[] {
+    const orders = this.createMany(count);
+    // Modify items to match category
+    orders.forEach(order => {
+      order.items = this.createOrderItems(1, category);
+      order.total_amount = order.items.reduce((sum, item) => sum + item.line_total, 0);
+    });
+    return orders;
+  }
+
+  /**
+   * Create order items
+   */
+  private createOrderItems(count: number, category?: string): OrderItem[] {
+    const items: OrderItem[] = [];
+    
+    for (let i = 0; i < count; i++) {
+      // Filter products by category if specified
+      const availableProducts = category 
+        ? this.products.filter(p => p.category === category)
+        : this.products;
+      
+      // Randomly select product
+      const product = faker.helpers.arrayElement(availableProducts);
+      
+      // Random quantity (1-3)
+      const quantity = faker.number.int({ min: 1, max: 3 });
+      
+      // Calculate line total
+      const lineTotal = product.price * quantity;
+      
+      items.push({
+        product_id: product.id,
+        name: product.name,
+        quantity,
+        unit_price: product.price,
+        line_total: Number(lineTotal.toFixed(2))
+      });
+    }
+    
+    return items;
+  }
+
+  /**
+   * Get random currency for international orders
+   */
+  private getRandomCurrency(): string {
+    return faker.helpers.arrayElement(['EUR', 'GBP', 'JPY', 'CAD', 'AUD']);
+  }
+}
+
+// Export singleton instance
+export const orderFactory = new OrderFactory();
+
+// Usage examples
+/*
+import { orderFactory } from './factories/order.factory';
+
+// Create single order
+const order = orderFactory.create();
+
+// Create multiple orders
+const orders = orderFactory.createMany(5);
+
+// Create specific scenarios
+const highValueOrders = orderFactory.createHighValueOrders(3);
+const internationalOrders = orderFactory.createInternationalOrders(2);
+
+// Create orders with status variations
+const pendingOrders = orderFactory.createPendingOrders(1);
+const confirmedOrders = orderFactory.createConfirmedOrders(2);
+const shippedOrders = orderFactory.createShippedOrders(1);
+const deliveredOrders = orderFactory.createDeliveredOrders(1);
+*/
+```
+
+## Data Quality Validation
+
+### Schema Validation and Constraints
+
+```python
+# validators/data_validator.py
+from typing import Dict, Any, List, Optional
+import jsonschema
+from jsonschema import validate
+import pandas as pd
+from datetime import datetime
+import re
+
+# JSON Schema definitions
+USER_SCHEMA = {
+    "type": "object",
+    "required": ["user_id", "first_name", "last_name", "email", "created_at"],
+    "properties": {
+        "user_id": {"type": "string", "pattern": "^USR[0-9]{5}$"},
+        "first_name": {"type": "string", "minLength": 1, "maxLength": 50},
+        "last_name": {"type": "string", "minLength": 1, "maxLength": 50},
+        "email": {"type": "string", "format": "email"},
+        "phone": {"type": "string", "pattern": "^\\+?[1-9][0-9]{1,14}$"},
+        "date_of_birth": {"type": "string", "format": "date"},
+        "status": {
+            "type": "string",
+            "enum": ["active", "inactive", "pending", "suspended"]
+        },
+        "created_at": {"type": "string", "format": "date-time"},
+        "updated_at": {"type": "string", "format": "date-time"}
+    }
+}
+
+ORDER_SCHEMA = {
+    "type": "object",
+    "required": ["order_id", "user_id", "items", "total_amount", "status", "created_at"],
+    "properties": {
+        "order_id": {"type": "string", "pattern": "^ORD[0-9]{8}[0-9]{4}$"},
+        "user_id": {"type": "string", "pattern": "^USR[0-9]{5}$"},
+        "items": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "required": ["product_id", "quantity", "unit_price", "line_total"],
+                "properties": {
+                    "product_id": {"type": "string"},
+                    "name": {"type": "string"},
+                    "quantity": {"type": "integer", "minimum": 1},
+                    "unit_price": {"type": "number", "minimum": 0},
+                    "line_total": {"type": "number", "minimum": 0}
+                }
+            }
+        },
+        "total_amount": {"type": "number", "minimum": 0},
+        "currency": {"type": "string", "maxLength": 3, "default": "USD"},
+        "status": {
+            "type": "string",
+            "enum": ["pending", "confirmed", "shipped", "delivered", "cancelled"]
+        },
+        "created_at": {"type": "string", "format": "date-time"},
+        "updated_at": {"type": "string", "format": "date-time"}
+    }
+}
+
+class DataValidator:
+    """Validate data against defined schemas and business rules"""
+    
+    def __init__(self):
+        self.schemas = {
+            'user': USER_SCHEMA,
+            'order': ORDER_SCHEMA
+        }
+    
+    def validate_schema(self, data: Dict[str, Any], schema_type: str) -> Dict[str, Any]:
+        """Validate data against JSON schema"""
+        if schema_type not in self.schemas:
+            raise ValueError(f"Unknown schema type: {schema_type}")
+        
+        try:
+            validate(instance=data, schema=self.schemas[schema_type])
+            return {"valid": True, "errors": []}
+        except jsonschema.exceptions.ValidationError as e:
+            return {
+                "valid": False,
+                "errors": [str(e)]
+            }
+    
+    def validate_user(self, user: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate user data with business rules"""
+        # Schema validation
+        schema_result = self.validate_schema(user, 'user')
+        if not schema_result['valid']:
+            return schema_result
+        
+        errors = []
+        
+        # Business rule validation
+        now = datetime.now()
+        
+        # Validate date of birth
+        if 'date_of_birth' in user and user['date_of_birth']:
+            dob = datetime.strptime(user['date_of_birth'], '%Y-%m-%d')
+            age = (now - dob).days // 365
+            if age < 13:
+                errors.append("User must be at least 13 years old")
+            if age > 120:
+                errors.append("User age seems unrealistic")
+        
+        # Validate email format beyond JSON schema
+        if 'email' in user:
+            # Check for disposable email domains
+            disposable_domains = ['tempmail.com', 'mailinator.com', '10minutemail.com']
+            domain = user['email'].split('@')[1].lower()
+            if domain in disposable_domains:
+                errors.append("Disposable email domains are not allowed")
+        
+        # Validate phone number format
+        if 'phone' in user and user['phone']:
+            digits = re.sub(r'\D', '', user['phone'])
+            if len(digits) < 10:
+                errors.append("Phone number must have at least 10 digits")
+        
+        # Validate name formatting
+        if 'first_name' in user and user['first_name']:
+            if not user['first_name'][0].isupper():
+                errors.append("First name should be capitalized")
+        
+        if 'last_name' in user and user['last_name']:
+            if not user['last_name'][0].isupper():
+                errors.append("Last name should be capitalized")
+        
+        return {
+            "valid": len(errors) == 0,
+            "errors": errors
+        }
+    
+    def validate_order(self, order: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate order data with business rules"""
+        # Schema validation
+        schema_result = self.validate_schema(order, 'order')
+        if not schema_result['valid']:
+            return schema_result
+        
+        errors = []
+        
+        # Business rule validation
+        
+        # Validate total amount matches items sum
+        expected_total = sum(item['line_total'] for item in order['items'])
+        if abs(order['total_amount'] - expected_total) > 0.01:  # Allow for floating point errors
+            errors.append(f"Total amount {order['total_amount']} does not match sum of items {expected_total}")
+        
+        # Validate item quantities and prices
+        for i, item in enumerate(order['items']):
+            if item['quantity'] <= 0:
+                errors.append(f"Item {i} has invalid quantity {item['quantity']}")
+            
+            if item['unit_price'] < 0:
+                errors.append(f"Item {i} has negative unit price {item['unit_price']}")
+            
+            expected_line_total = item['quantity'] * item['unit_price']
+            if abs(item['line_total'] - expected_line_total) > 0.01:
+                errors.append(f"Item {i} line total {item['line_total']} does not match quantity * unit price {expected_line_total}")
+        
+        # Validate status transitions
+        if 'status' in order and 'previous_status' in order:
+            valid_transitions = {
+                'pending': ['confirmed', 'cancelled'],
+                'confirmed': ['shipped', 'cancelled'],
+                'shipped': ['delivered', 'cancelled'],
+                'delivered': [],
+                'cancelled': []
+            }
+            
+            if order['previous_status'] not in valid_transitions:
+                errors.append(f"Unknown previous status {order['previous_status']}")
+            elif order['status'] not in valid_transitions[order['previous_status']]:
+                errors.append(f"Invalid status transition from {order['previous_status']} to {order['status']}")
+        
+        # Validate timestamps
+        if 'created_at' in order and 'updated_at' in order:
+            created = datetime.fromisoformat(order['created_at'].replace('Z', '+00:00'))
+            updated = datetime.fromisoformat(order['updated_at'].replace('Z', '+00:00'))
+            if updated < created:
+                errors.append("Updated timestamp cannot be before created timestamp")
+        
+        return {
+            "valid": len(errors) == 0,
+            "errors": errors
+        }
+    
+    def validate_dataset(self, df: pd.DataFrame, entity_type: str) -> Dict[str, Any]:
+        """Validate entire dataset for data quality"""
+        if entity_type == 'user':
+            validator_func = self.validate_user
+        elif entity_type == 'order':
+            validator_func = self.validate_order
+        else:
+            raise ValueError(f"Unsupported entity type: {entity_type}")
+        
+        results = {
+            'total_records': len(df),
+            'valid_records': 0,
+            'invalid_records': 0,
+            'errors': [],
+            'field_completeness': {},
+            'summary': {}
+        }
+        
+        # Check field completeness
+        for column in df.columns:
+            completeness = df[column].notna().mean()
+            results['field_completeness'][column] = round(completeness * 100, 2)
+        
+        # Validate each record
+        for idx, row in df.iterrows():
+            validation = validator_func(row.to_dict())
+            
+            if validation['valid']:
+                results['valid_records'] += 1
+            else:
+                results['invalid_records'] += 1
+                for error in validation['errors']:
+                    results['errors'].append(f"Record {idx}: {error}")
+        
+        # Generate summary
+        results['summary'] = {
+            'validity_rate': round(results['valid_records'] / results['total_records'] * 100, 2) if results['total_records'] > 0 else 0,
+            'completeness_rate': round(sum(results['field_completeness'].values()) / len(results['field_completeness']) if results['field_completeness'] else 0, 2)
+        }
+        
+        return results
+
+# Usage example
+if __name__ == "__main__":
+    validator = DataValidator()
+    
+    # Test user validation
+    test_user = {
+        'user_id': 'USR12345',
+        'first_name': 'John',
+        'last_name': 'Smith',
+        'email': 'john.smith@example.com',
+        'phone': '+1-555-123-4567',
+        'date_of_birth': '1990-01-15',
+        'status': 'active',
+        'created_at': '2025-01-15T10:30:00Z',
+        'updated_at': '2025-01-15T10:30:00Z'
+    }
+    
+    result = validator.validate_user(test_user)
+    print("User validation:", result)
+    
+    # Test order validation
+    test_order = {
+        'order_id': 'ORD202501151234',
+        'user_id': 'USR12345',
+        'items': [
+            {
+                'product_id': 'PROD001',
+                'name': 'Test Product',
+                'quantity': 2,
+                'unit_price': 25.00,
+                'line_total': 50.00
+            }
+        ],
+        'total_amount': 50.00,
+        'status': 'pending',
+        'created_at': '2025-01-15T10:30:00Z',
+        'updated_at': '2025-01-15T10:30:00Z'
+    }
+    
+    result = validator.validate_order(test_order)
+    print("Order validation:", result)
+```
+
+### Data Quality Dashboard
+
+```python
+# dashboards/data_quality.py
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import warnings
+warnings.filterwarnings('ignore')
+
+class DataQualityDashboard:
+    """Generate interactive data quality dashboards"""
+    
+    def __init__(self):
+        self.colors = {
+            'primary': '#1f77b4',
+            'secondary': '#ff7f0e',
+            'success': '#2ca02c',
+            'danger': '#d62728',
+            'warning': '#ffbb78',
+            'info': '#17becf'
+        }
+    
+    def create_overview_dashboard(self, validation_results: Dict[str, Any], 
+                                 time_series_data: pd.DataFrame = None) -> go.Figure:
+        """Create comprehensive data quality overview dashboard"""
+        fig = make_subplots(
+            rows=3, cols=2,
+            subplot_titles=[
+                'Data Validity', 'Field Completeness',
+                'Error Distribution', 'Validation Trends',
+                'Top Data Issues', 'Completeness by Field'
+            ],
+            specs=[
+                [{"type": "domain"}, {"type": "bar"}],
+                [{"type": "pie"}, {"type": "scatter"}],
+                [{"type": "table"}, {"type": "bar"}]
+            ],
+            vertical_spacing=0.1,
+            horizontal_spacing=0.1
+        )
+        
+        # 1. Data Validity (Donut chart)
+        validity_data = {
+            'labels': ['Valid', 'Invalid'],
+            'values': [
+                validation_results['valid_records'], 
+                validation_results['invalid_records']
+            ]
+        }
+        
+        fig.add_trace(
+            go.Pie(
+                labels=validity_data['labels'],
+                values=validity_data['values'],
+                hole=0.4,
+                marker_colors=[self.colors['success'], self.colors['danger']],
+                textinfo='percent+label',
+                textposition='outside'
+            ),
+            row=1, col=1
+        )
+        
+        # 2. Field Completeness (Bar chart)
+        completeness_data = list(validation_results['field_completeness'].items())
+        completeness_data.sort(key=lambda x: x[1], reverse=True)
+        
+        fig.add_trace(
+            go.Bar(
+                x=[item[0] for item in completeness_data],
+                y=[item[1] for item in completeness_data],
+                marker_color=[
+                    self.colors['success'] if item[1] >= 95 else 
+                    self.colors['warning'] if item[1] >= 80 else 
+                    self.colors['danger'] 
+                    for item in completeness_data
+                ],
+                text=[f"{item[1]:.1f}%" for item in completeness_data],
+                textposition='auto'
+            ),
+            row=1, col=2
+        )
+        
+        # 3. Error Distribution (Pie chart)
+        # Extract error types from error messages
+        error_types = {}
+        for error in validation_results['errors']:
+            # Extract main error type from message
+            if 'email' in error.lower():
+                error_type = 'Email Issues'
+            elif 'phone' in error.lower():
+                error_type = 'Phone Issues'
+            elif 'date' in error.lower():
+                error_type = 'Date Issues'
+            elif 'schema' in error.lower():
+                error_type = 'Schema Issues'
+            elif 'business' in error.lower():
+                error_type = 'Business Rule Issues'
+            else:
+                error_type = 'Other Issues'
+            
+            error_types[error_type] = error_types.get(error_type, 0) + 1
+        
+        fig.add_trace(
+            go.Pie(
+                labels=list(error_types.keys()),
+                values=list(error_types.values()),
+                marker_colors=[self.colors['danger'], self.colors['warning'], 
+                             self.colors['info'], self.colors['secondary'], 
+                             self.colors['primary']],
+                textinfo='percent+label',
+                textposition='outside'
+            ),
+            row=2, col=1
+        )
+        
+        # 4. Validation Trends (Line chart)
+        if time_series_data is not None and not time_series_data.empty:
+            # Assume time_series_data has columns: date, valid_count, invalid_count, completeness_rate
+            fig.add_trace(
+                go.Scatter(
+                    x=time_series_data['date'],
+                    y=time_series_data['validity_rate'],
+                    mode='lines+markers',
+                    name='Validity Rate',
+                    line=dict(color=self.colors['success'], width=3)
+                ),
+                row=2, col=2
+            )
+            
+            fig.add_trace(
+                go.Scatter(
+                    x=time_series_data['date'],
+                    y=time_series_data['completeness_rate'],
+                    mode='lines+markers',
+                    name='Completeness Rate',
+                    line=dict(color=self.colors['primary'], width=3, dash='dot')
+                ),
+                row=2, col=2
+            )
+        
+        # 5. Top Data Issues (Table)
+        error_series = pd.Series(validation_results['errors'])
+        top_issues = error_series.value_counts().head(5)
+        
+        fig.add_trace(
+            go.Table(
+                header=dict(
+                    values=['Issue', 'Count'],
+                    fill_color='paleturquoise',
+                    align='left'
+                ),
+                cells=dict(
+                    values=[top_issues.index, top_issues.values],
+                    fill_color='lavender',
+                    align='left'
+                )
+            ),
+            row=3, col=1
+        )
+        
+        # 6. Completeness by Field (Horizontal Bar)
+        fig.add_trace(
+            go.Bar(
+                y=[item[0] for item in completeness_data],
+                x=[item[1] for item in completeness_data],
+                orientation='h',
+                marker_color=[
+                    self.colors['success'] if item[1] >= 95 else 
+                    self.colors['warning'] if item[1] >= 80 else 
+                    self.colors['danger'] 
+                    for item in completeness_data
+                ],
+                text=[f"{item[1]:.1f}%" for item in completeness_data],
+                textposition='auto'
+            ),
+            row=3, col=2
+        )
+        
+        # Update layout
+        fig.update_layout(
+            title={
+                'text': 'Data Quality Dashboard',
+                'x': 0.5,
+                'xanchor': 'center',
+                'font': {'size': 24}
+            },
+            height=1200,
+            showlegend=False,
+            margin=dict(l=50, r=50, t=80, b=50)
+        )
+        
+        # Update subplot titles font size
+        for annotation in fig['layout']['annotations']:
+            annotation['font'] = dict(size=14)
+        
+        return fig
+    
+    def create_field_analysis_dashboard(self, df: pd.DataFrame, field_name: str) -> go.Figure:
+        """Create detailed analysis dashboard for a specific field"""
+        # Get field data, handling potential missing field
+        if field_name not in df.columns:
+            raise ValueError(f"Field '{field_name}' not found in dataframe")
+            
+        field_data = df[field_name].copy()
+        
+        # Create subplots
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=[
+                f'{field_name} Distribution',
+                f'{field_name} Completeness Over Time',
+                f'{field_name} Completeness by Category',
+                f'{field_name} Top Values'
+            ],
+            specs=[[{"type": "histogram"}, {"type": "scatter"}],
+                   ["", {"type": "bar"}]],
+            vertical_spacing=0.15,
+            horizontal_spacing=0.1
+        )
+        
+        # Remove empty subplot (row=2, col=1)
+        fig.layout['xaxis3'].update(showticklabels=False, showgrid=False, zeroline=False)
+        fig.layout['yaxis3'].update(visible=False)
+        
+        # 1. Distribution (Histogram)
+        # For numeric fields
+        if pd.api.types.is_numeric_dtype(field_data):
+            fig.add_trace(
+                go.Histogram(
+                    x=field_data.dropna(),
+                    nbinsx=50,
+                    marker_color=self.colors['primary']
+                ),
+                row=1, col=1
+            )
+            
+            # Add summary statistics
+            summary_text = (
+                f"Mean: {field_data.mean():.2f}<br>"
+                f"Std: {field_data.std():.2f}<br>"
+                f"Min: {field_data.min():.2f}<br>"
+                f"Max: {field_data.max():.2f}<br>"
+                f"Nulls: {field_data.isna().sum()} ({field_data.isna().mean()*100:.1f}%)")
+            
+            fig.add_annotation(
+                xref="x domain", yref="y domain",
+                x=0.02, y=0.98,
+                text=summary_text,
+                showarrow=False,
+                bgcolor="white",
+                bordercolor="black",
+                borderwidth=1,
+                opacity=0.8,
+                align="left"
+            )
+        
+        # For categorical fields
+        else:
+            # Convert to string and handle nulls
+            field_data = field_data.astype(str)
+            field_data = field_data.replace('nan', 'Null')
+            
+            # Get top 10 values
+            value_counts = field_data.value_counts().head(10)
+            
+            fig.add_trace(
+                go.Bar(
+                    x=value_counts.index,
+                    y=value_counts.values,
+                    marker_color=self.colors['primary']
+                ),
+                row=1, col=1
+            )
+            
+            # Add summary
+            summary_text = (
+                f"Unique values: {field_data.nunique()}<br>"
+                f"Total records: {len(field_data)}<br>"
+                f"Nulls: {field_data.isin(['Null', '']).sum()} ({(field_data.isin(['Null', ''])).mean()*100:.1f}%)")
+            
+            fig.add_annotation(
+                xref="x domain", yref="y domain",
+                x=0.02, y=0.98,
+                text=summary_text,
+                showarrow=False,
+                bgcolor="white",
+                bordercolor="black",
+                borderwidth=1,
+                opacity=0.8,
+                align="left"
+            )
+        
+        # 2. Completeness Over Time (if date column exists)
+        date_columns = [col for col in df.columns if 'date' in col.lower() or 'time' in col.lower()]
+        if date_columns:
+            date_col = date_columns[0]  # Use first date column
+            df_sorted = df.sort_values(date_col)
+            
+            # Convert date if needed
+            if not pd.api.types.is_datetime64_any_dtype(df_sorted[date_col]):
+                df_sorted[date_col] = pd.to_datetime(df_sorted[date_col])
+                
+            # Calculate completeness over time (rolling 7-day window)
+            df_sorted = df_sorted.set_index(date_col)
+            completeness_rolling = df_sorted[field_name].notna().rolling('7D').mean()
+            
+            fig.add_trace(
+                go.Scatter(
+                    x=completeness_rolling.index,
+                    y=completeness_rolling.values * 100,
+                    mode='lines',
+                    line=dict(color=self.colors['success'], width=3),
+                    name='Completeness'
+                ),
+                row=1, col=2
+            )
+            
+            # Add horizontal line for overall completeness
+            overall_completeness = df[field_name].notna().mean() * 100
+            fig.add_hline(
+                y=overall_completeness,
+                line_dash="dot",
+                line_color=self.colors['primary'],
+                annotation_text=f"Overall: {overall_completeness:.1f}%",
+                annotation_position="top left",
+                row=1, col=2
+            )
+        
+        # 3. Completeness by Category (if categorical columns exist)
+        # Find potential category columns (low cardinality categorical)
+        categorical_cols = []
+        for col in df.columns:
+            if col != field_name and col != date_col:
+                if (df[col].dtype == 'object' and 
+                    df[col].nunique() <= 10 and 
+                    df[col].nunique() > 1):
+                    categorical_cols.append(col)
+        
+        if categorical_cols:
+            category_col = categorical_cols[0]  # Use first suitable category column
+            completeness_by_category = df.groupby(category_col)[field_name].apply(
+                lambda x: x.notna().mean() * 100
+            ).round(1)
+            
+            fig.add_trace(
+                go.Bar(
+                    x=completeness_by_category.index,
+                    y=completeness_by_category.values,
+                    marker_color=[
+                        self.colors['success'] if val >= 95 else 
+                        self.colors['warning'] if val >= 80 else 
+                        self.colors['danger'] 
+                        for val in completeness_by_category.values
+                    ],
+                    text=[f"{val:.1f}%" for val in completeness_by_category.values],
+                    textposition='auto'
+                ),
+                row=2, col=2
+            )
+            
+            # Update subplot title to show the category
+            fig.layout.annotations[2].text = f"{field_name} Completeness by {category_col.title()}"
+        
+        # 4. Top Values (for categorical fields)
+        if not pd.api.types.is_numeric_dtype(field_data):
+            # Get top 10 values
+            top_values = field_data.value_counts().head(10)
+            
+            fig.add_trace(
+                go.Bar(
+                    x=top_values.values,
+                    y=top_values.index,
+                    orientation='h',
+                    marker_color=self.colors['primary']
+                ),
+                row=2, col=2
+            )
+            
+            # Update subplot title
+            fig.layout.annotations[3].text = f"Top {field_name} Values"
+        
+        # Update layout
+        fig.update_layout(
+            title={
+                'text': f'Detailed Analysis: {field_name}',
+                'x': 0.5,
+                'xanchor': 'center',
+                'font': {'size': 20}
+            },
+            height=800,
+            showlegend=False,
+            margin=dict(l=50, r=50, t=80, b=50)
+        )
+        
+        # Update subplot titles font size
+        for annotation in fig['layout']['annotations']:
+            annotation['font'] = dict(size=12)
+        
+        return fig
+    
+    def export_dashboard(self, fig: go.Figure, filepath: str, format: str = 'html') -> None:
+        """Export dashboard to file"""
+        if format == 'html':
+            fig.write_html(filepath)
+        elif format == 'png':
+            fig.write_image(filepath, width=1200, height=800)
+        elif format == 'pdf':
+            fig.write_image(filepath)
+        else:
+            raise ValueError(f"Unsupported format: {format}")
+
+# Usage example
+if __name__ == "__main__":
+    # Create sample data for demonstration
+    np.random.seed(42)
+    dates = pd.date_range('2025-01-01', '2025-03-31', freq='D')
+    
+    time_series_data = pd.DataFrame({
+        'date': dates,
+        'validity_rate': np.random.normal(95, 5, len(dates)).clip(80, 100),
+        'completeness_rate': np.random.normal(92, 8, len(dates)).clip(70, 100)
+    })
+    
+    # Create validation results
+    validation_results = {
+        'total_records': 1000,
+        'valid_records': 920,
+        'invalid_records': 80,
+        'field_completeness': {
+            'user_id': 100.0,
+            'first_name': 98.5,
+            'last_name': 98.0,
+            'email': 96.2,
+            'phone': 85.3,
+            'date_of_birth': 92.1,
+            'status': 100.0,
+            'created_at': 100.0,
+            'updated_at': 100.0
+        },
+        'errors': [
+            'User 10: Invalid email format',
+            'User 15: Phone number too short',
+            'User 23: Date of birth in future',
+            'User 34: First name not capitalized',
+            'User 45: Disposable email domain',
+            'User 10: Invalid email format',
+            'User 15: Phone number too short',
+            'User 23: Date of birth in future'
+        ]
+    }
+    
+    # Create dashboard
+    dashboard = DataQualityDashboard()
+    fig = dashboard.create_overview_dashboard(validation_results, time_series_data)
+    fig.show()
+    
+    # Export to HTML
+    dashboard.export_dashboard(fig, 'data_quality_dashboard.html', 'html')
+```
diff --git a/Claude/skills/test-environment-management.md b/Claude/skills/test-environment-management.md
new file mode 100644
index 0000000..22da253
--- /dev/null
+++ b/Claude/skills/test-environment-management.md
@@ -0,0 +1,756 @@
+---
+type: skill
+name: test-environment-management
+description: Framework for managing test environments, configuration, data provisioning, isolation, and lifecycle automation.
+origin: ECC
+---
+
+# Test Environment Management
+
+Use this skill to design, provision, configure, isolate, monitor, and retire test environments that reflect production behavior without compromising reliability or safety.
+
+## When to use this skill
+
+- Defining environment tiers for development, staging, integration, end-to-end, or performance testing
+- Standardizing configuration, secrets handling, and data provisioning across environments
+- Automating lifecycle tasks such as setup, reset, teardown, and drift detection
+- Improving environment isolation, observability, and reproducibility in CI/CD pipelines
+
+## Core areas
+
+- Environment configuration and hierarchy
+- Test data provisioning and reset strategies
+- Isolation and parallel test execution
+- CI workflow integration
+- Cloud provisioning and ephemeral environments
+- Monitoring, health checks, and incident response
+
+## Recommended reference file split
+
+Keep this primary skill file concise and move detailed reference material into companion files such as:
+
+- `references/configuration.md`
+- `references/test-data.md`
+- `references/isolation.md`
+- `references/ci-workflow.md`
+- `references/cloud-provisioning.md`
+- `references/monitoring.md`
+
+## Quick guidance
+
+1. Start from a shared baseline configuration.
+2. Apply environment-specific overrides and secrets securely.
+3. Provision deterministic test data and clear teardown rules.
+4. Isolate tests by tenant, namespace, account, or ephemeral stack.
+5. Add health checks, observability, and drift detection.
+6. Prefer automation for creation, reset, and cleanup.
+
+## Notes
+
+Detailed examples, large YAML samples, CI workflows, cloud provisioning guidance, and monitoring runbooks should be stored in the reference files listed above rather than embedded in the primary skill document.
+  ssl_required: true
+  cors:
+    allowed_origins: ["${FRONTEND_URL}"]
+    allowed_methods: ["GET", "POST", "PUT", "DELETE"]
+
+# Environment-specific override
+# environments/staging/overrides.yaml
+app:
+  environment: "staging"
+  feature_flags:
+    new_payment_gateway: true
+    enhanced_reporting: false
+
+api:
+  base_url: "https://api.staging.example.com"
+  timeout: 45000
+
+logging:
+  level: "debug"
+```
+
+## Test Data Strategy
+
+### Data Provisioning Patterns
+
+**Clean Slate Pattern**:
+```python
+# tests/conftest.py
+import pytest
+from database import DatabaseClient
+
+def setup_clean_database():
+    """Reset database to known state before test suite"""
+    db = DatabaseClient()
+    db.drop_all_collections()
+    db.create_collections()
+    db.load_fixtures('fixtures/common.yaml')
+    db.load_fixtures(f'fixtures/{test_env}.yaml')
+    return db
+
+@ pytest.fixture(scope="session")
+def database():
+    return setup_clean_database()
+```
+
+**Data Seeding Service**:
+```javascript
+// services/data-seeder.js
+const faker = require('faker');
+const axios = require('axios');
+
+class DataSeeder {
+  constructor(config) {
+    this.apiClient = axios.create({
+      baseURL: config.apiBaseURL,
+      headers: { 'Authorization': `Bearer ${config.accessToken}` }
+    });
+    this.config = config;
+  }
+
+  async seedUsers(count) {
+    const users = [];
+    for (let i = 0; i < count; i++) {
+      const userData = {
+        email: faker.internet.email(),
+        name: faker.name.findName(),
+        age: faker.datatype.number({ min: 18, max: 80 }),
+        status: ['active', 'inactive', 'pending'][
+          faker.datatype.number({ min: 0, max: 2 })
+        ]
+      };
+      
+      const response = await this.apiClient.post('/users', userData);
+      users.push(response.data);
+    }
+    return users;
+  }
+
+  async seedOrders(userId, count) {
+    const orders = [];
+    for (let i = 0; i < count; i++) {
+      const orderData = {
+        user_id: userId,
+        items: this.generateOrderItems(),
+        total: faker.commerce.price(),
+        status: ['pending', 'confirmed', 'shipped', 'delivered']
+          [faker.datatype.number({ min: 0, max: 3 })]
+      };
+      
+      const response = await this.apiClient.post('/orders', orderData);
+      orders.push(response.data);
+    }
+    return orders;
+  }
+}
+
+module.exports = DataSeeder;
+```
+
+## Test Isolation
+
+### Containerized Environment Spinning
+
+```dockerfile
+# Dockerfile.test
+FROM node:18-alpine
+
+# Install testing tools
+RUN apk add --no-cache \
+    chromium \
+    firefox \
+    tzdata \
+    unzip
+
+# Install Playwright browsers
+RUN npm install -g @playwright/test && \
+    npx playwright install --with-deps chromium firefox
+
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production
+COPY . .
+
+# Create non-root user
+RUN addgroup -g 1001 -S playwright && \
+    adduser -u 1001 -S playwright -G playwright
+USER playwright
+
+CMD ["npm", "run", "test:e2e"]
+```
+
+```yaml
+# docker-compose.test.yml
+version: '3.8'
+
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile.test
+    environment:
+      - NODE_ENV=test
+      - DATABASE_URL=mongodb://mongo:27017/testdb
+      - REDIS_URL=redis://redis:6379
+      - API_BASE_URL=http://api:3000
+    depends_on:
+      - mongo
+      - redis
+      - api
+    networks:
+      - test-network
+
+  api:
+    image: myapp-api:staging
+    environment:
+      - MONGODB_URI=mongodb://mongo:27017/staging
+      - REDIS_URL=redis://redis:6379
+    ports:
+      - "3000:3000"
+    networks:
+      - test-network
+
+  mongo:
+    image: mongo:6.0
+    volumes:
+      - mongo-data:/data/db
+    networks:
+      - test-network
+
+  redis:
+    image: redis:7.0-alpine
+    networks:
+      - test-network
+
+  proxy:
+    image: nginx:alpine
+    volumes:
+      - ./nginx.test.conf:/etc/nginx/nginx.conf
+    ports:
+      - "8080:8080"
+    depends_on:
+      - app
+    networks:
+      - test-network
+
+volumes:
+  mongo-data:
+
+networks:
+  test-network:
+    driver: bridge
+```
+
+### Test-Specific Configuration
+
+```typescript
+// utils/test-environment.ts
+import fs from 'fs';
+import yaml from 'js-yaml';
+import { merge } from 'lodash';
+
+interface TestEnvironmentConfig {
+  envType: 'integration' | 'e2e' | 'performance';
+  timeout: number;
+  retries: number;
+  headless: boolean;
+  captureLogs: boolean;
+  videoRecording: boolean;
+}
+
+class TestEnvironment {
+  private static instance: TestEnvironment;
+  private config: any;
+  private envConfig: TestEnvironmentConfig;
+
+  private constructor() {
+    this.loadConfiguration();
+    this.setupEnvironment();
+  }
+
+  public static getInstance(): TestEnvironment {
+    if (!TestEnvironment.instance) {
+      TestEnvironment.instance = new TestEnvironment();
+    }
+    return TestEnvironment.instance;
+  }
+
+  private loadConfiguration() {
+    // Load common configuration
+    const commonConfig = yaml.load(
+      fs.readFileSync('environments/common/config.yaml', 'utf8'));
+    
+    // Load environment-specific configuration
+    const env = process.env.TEST_ENV || 'development';
+    const envConfig = yaml.load(
+      fs.readFileSync(`environments/${env}/base.yaml`, 'utf8'));
+    
+    // Load test-specific configuration
+    const testType = process.env.TEST_TYPE || 'e2e';
+    const testConfig = yaml.load(
+      fs.readFileSync(`environments/test-specific/${testType}.yaml`, 'utf8'));
+    
+    // Deep merge configurations
+    this.config = merge({}, commonConfig, envConfig, testConfig);
+  }
+
+  private setupEnvironment() {
+    // Set environment variables
+    process.env.API_BASE_URL = this.config.api.base_url;
+    process.env.LOG_LEVEL = this.config.logging.level;
+    
+    // Configure test framework
+    this.envConfig = {
+      envType: process.env.TEST_TYPE as any,
+      timeout: this.config.api.timeout,
+      retries: this.config.api.retry_attempts,
+      headless: process.env.HEADLESS !== 'false',
+      captureLogs: this.config.logging.audit_trail,
+      videoRecording: process.env.VIDEO_RECORDING === 'true'
+    };
+  }
+
+  public getConfig(): any {
+    return this.config;
+  }
+
+  public getEnvConfig(): TestEnvironmentConfig {
+    return this.envConfig;
+  }
+
+  public async setupTestDatabase(): Promise<void> {
+    // Setup database state specific to test
+    console.log(`Setting up database for ${this.envConfig.envType} tests`);
+    // Implementation details...
+  }
+
+  public async teardown(): Promise<void> {
+    // Cleanup resources
+    console.log('Tearing down test environment');
+    // Implementation details...
+  }
+}
+
+export default TestEnvironment;
+```
+
+## Environment Lifecycle Automation
+
+### CI/CD Pipeline Integration
+
+```yaml
+# .github/workflows/test-environment.yml
+name: Test Environment Management
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  setup-test-environment:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        test-type: [integration, e2e, performance]
+    environment: ${{ matrix.test-type }}
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '18'
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Decrypt secrets
+      run: |
+        echo "${{ secrets.ENV_SECRETS }}" > secrets.enc
+        openssl aes-256-cbc -d -in secrets.enc -out environments/secrets.yaml -k "$SECRETS_KEY"
+      env:
+        SECRETS_KEY: ${{ secrets.SECRETS_KEY }}
+
+    - name: Start test environment
+      run: |
+        export TEST_ENV=${{ matrix.test-type }}
+        export TEST_TYPE=${{ matrix.test-type }}
+        docker-compose -f docker-compose.test.yml up -d
+
+    - name: Wait for services to be ready
+      run: |
+        # Wait for API to be responsive
+        timeout 120 bash -c 'until curl -s http://localhost:3000/health; do sleep 5; done' || exit 1
+        
+        # Wait for database to be ready
+        timeout 60 bash -c 'until docker exec mongo mongosh --eval "db.adminCommand('ping')'"; do sleep 5; done' || exit 1
+
+    - name: Run data provisioning
+      run: |
+        export TEST_ENV=${{ matrix.test-type }}
+        npm run data:seed -- --count=50 --type=users
+        npm run data:seed -- --count=100 --type=orders
+
+    - name: Run tests
+      run: |
+        export TEST_ENV=${{ matrix.test-type }}
+        export VIDEO_RECORDING=true
+        npm run test:${{ matrix.test-type }}
+
+    - name: Collect artifacts
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: test-results-${{ matrix.test-type }}
+        path: |
+          test-results/
+          videos/
+          logs/
+        retention-days: 30
+
+    - name: Teardown environment
+      if: always()
+      run: |
+        docker-compose -f docker-compose.test.yml down
+        docker system prune -f
+```
+
+### Dynamic Environment Provisioning
+
+```python
+# scripts/provision-environment.py
+import boto3
+import yaml
+import subprocess
+import time
+from typing import Dict, Any
+
+class CloudEnvironmentProvisioner:
+    def __init__(self, config_file: str):
+        self.config = self.load_config(config_file)
+        self.ec2 = boto3.client('ec2')
+        self.rds = boto3.client('rds')
+        self.elasticache = boto3.client('elasticache')
+
+    def load_config(self, config_file: str) -> Dict[str, Any]:
+        with open(config_file, 'r') as f:
+            return yaml.safe_load(f)
+
+    def create_vpc(self, name: str) -> str:
+        """Create isolated VPC for test environment"""
+        vpc = self.ec2.create_vpc(
+            CidrBlock='10.0.0.0/16',
+            TagSpecifications=[
+                {
+                    'ResourceType': 'vpc',
+                    'Tags': [
+                        {'Key': 'Name', 'Value': name},
+                        {'Key': 'Environment', 'Value': 'test'}
+                    ]
+                }
+            ]
+        )
+        vpc_id = vpc['Vpc']['VpcId']
+        
+        # Enable DNS hostnames
+        self.ec2.modify_vpc_attribute(
+            VpcId=vpc_id,
+            EnableDnsHostnames={'Value': True}
+        )
+        
+        return vpc_id
+
+    def create_test_environment(self, env_name: str, env_type: str) -> Dict[str, str]:
+        """Provision complete test environment in cloud"""
+        print(f"Provisioning {env_type} environment: {env_name}")
+        
+        # Create VPC
+        vpc_id = self.create_vpc(env_name)
+        
+        # Create subnets
+        public_subnet = self.ec2.create_subnet(
+            VpcId=vpc_id,
+            CidrBlock='10.0.1.0/24',
+            AvailabilityZone='us-west-2a'
+        )
+        
+        private_subnet = self.ec2.create_subnet(
+            VpcId=vpc_id,
+            CidrBlock='10.0.2.0/24',
+            AvailabilityZone='us-west-2a'
+        )
+        
+        # Create security groups
+        api_sg = self.create_security_group(
+            vpc_id, f"{env_name}-api-sg", "API Security Group"
+        )
+        
+        db_sg = self.create_security_group(
+            vpc_id, f"{env_name}-db-sg", "Database Security Group"
+        )
+        
+        # Authorize security group rules
+        self.ec2.authorize_security_group_ingress(
+            GroupId=api_sg,
+            IpPermissions=[
+                {
+                    'IpProtocol': 'tcp',
+                    'FromPort': 3000,
+                    'ToPort': 3000,
+                    'IpRanges': [{'CidrIp': '0.0.0.0/0'}]
+                }
+            ]
+        )
+        
+        self.ec2.authorize_security_group_ingress(
+            GroupId=db_sg,
+            IpPermissions=[
+                {
+                    'IpProtocol': 'tcp',
+                    'FromPort': 27017,
+                    'ToPort': 27017,
+                    'UserIdGroupPairs': [{'GroupId': api_sg}]
+                }
+            ]
+        )
+        
+        # Create RDS MongoDB instance
+        db_instance = self.rds.create_db_instance(
+            DBInstanceIdentifier=f"{env_name.lower()}-db",
+            DBInstanceClass='db.t3.small',
+            Engine='mongodb',
+            MasterUsername=self.config['database']['username'],
+            MasterUserPassword=self.config['database']['password'],
+            AllocatedStorage=20,
+            VpcSecurityGroupIds=[db_sg],
+            DBSubnetGroupName=self.create_db_subnet_group(vpc_id, private_subnet['Subnet']['SubnetId'])
+        )
+        
+        # Create ElastiCache Redis cluster
+        cache_cluster = self.elasticache.create_cache_cluster(
+            CacheClusterId=f"{env_name.lower()}-cache",
+            NumCacheNodes=1,
+            CacheNodeType='cache.t3.micro',
+            Engine='redis',
+            VpcSecurityGroupIds=[api_sg],
+            SubnetGroupName=self.create_cache_subnet_group(vpc_id, private_subnet['Subnet']['SubnetId'])
+        )
+        
+        # Wait for resources to be available
+        print("Waiting for database to be available...")
+        waiter = self.rds.get_waiter('db_instance_available')
+        waiter.wait(DBInstanceIdentifier=f"{env_name.lower()}-db")
+        
+        # Deploy application using ECS or EC2
+        app_endpoint = self.deploy_application(
+            env_name, api_sg, public_subnet['Subnet']['SubnetId']
+        )
+        
+        # Return environment details
+        return {
+            'environment_name': env_name,
+            'vpc_id': vpc_id,
+            'api_endpoint': app_endpoint,
+            'database_endpoint': db_instance['DBInstance']['Endpoint']['Address'],
+            'cache_endpoint': cache_cluster['CacheCluster']['ConfigurationEndpoint']['Address'],
+            'status': 'provisioned'
+        }
+    
+    def create_security_group(self, vpc_id: str, name: str, description: str) -> str:
+        sg = self.ec2.create_security_group(
+            GroupName=name,
+            Description=description,
+            VpcId=vpc_id
+        )
+        return sg['GroupId']
+    
+    def create_db_subnet_group(self, vpc_id: str, subnet_id: str) -> str:
+        group_name = f"{vpc_id}-db-subnet"
+        self.rds.create_db_subnet_group(
+            DBSubnetGroupName=group_name,
+            DBSubnetGroupDescription='DB Subnet Group',
+            SubnetIds=[subnet_id]
+        )
+        return group_name
+    
+    def create_cache_subnet_group(self, vpc_id: str, subnet_id: str) -> str:
+        group_name = f"{vpc_id}-cache-subnet"
+        self.elasticache.create_cache_subnet_group(
+            CacheSubnetGroupName=group_name,
+            CacheSubnetGroupDescription='Cache Subnet Group',
+            SubnetIds=[subnet_id]
+        )
+        return group_name
+    
+    def deploy_application(self, env_name: str, security_group: str, subnet_id: str) -> str:
+        # Deploy application using ECS, EC2, or EKS
+        # Return application endpoint
+        pass
+
+# Usage
+if __name__ == "__main__":
+    provisioner = CloudEnvironmentProvisioner('config/environment-config.yaml')
+    env_details = provisioner.create_test_environment('e2e-test-001', 'e2e')
+    print(f"Environment provisioned: {env_details['api_endpoint']}")
+    
+    # Save environment details for teardown
+    with open(f"environments/{env_details['environment_name']}.json", 'w') as f:
+        json.dump(env_details, f, indent=2)
+```
+
+## Environment Monitoring and Telemetry
+
+### Health Checks and Readiness Probes
+
+```yaml
+# kubernetes/test-environment.yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: test-api
+  namespace: test
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: test-api
+  template:
+    metadata:
+      labels:
+        app: test-api
+    spec:
+      containers:
+      - name: api
+        image: myapp-api:staging
+        env:
+        - name: NODE_ENV
+          value: test
+        - name: DATABASE_URL
+          value: mongodb://test-db:27017/testdb
+        ports:
+        - containerPort: 3000
+        readinessProbe:
+          httpGet:
+            path: /health/readiness
+            port: 3000
+          initialDelaySeconds: 10
+          periodSeconds: 5
+          timeoutSeconds: 3
+          successThreshold: 1
+          failureThreshold: 3
+        livenessProbe:
+          httpGet:
+            path: /health/liveness
+            port: 3000
+          initialDelaySeconds: 30
+          periodSeconds: 10
+          timeoutSeconds: 5
+          successThreshold: 1
+          failureThreshold: 3
+        startupProbe:
+          httpGet:
+            path: /health/startup
+            port: 3000
+          failureThreshold: 30
+          periodSeconds: 10
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: test-api
+  namespace: test
+spec:
+  selector:
+    app: test-api
+  ports:
+    - protocol: TCP
+      port: 80
+      targetPort: 3000
+  type: ClusterIP
+```
+
+### Environment Teardown Strategy
+
+```javascript
+// utils/environment-teardown.js
+const { exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+async function teardownEnvironment() {
+  const envName = process.env.ENV_NAME || 'test';
+  const deploymentType = process.env.DEPLOYMENT_TYPE || 'docker';
+  
+  console.log(`Tearing down ${envName} environment...`);
+  
+  try {
+    if (deploymentType === 'docker') {
+      // Docker Compose teardown
+      await executeCommand('docker-compose -f docker-compose.test.yml down --remove-orphans');
+      await executeCommand('docker network prune -f');
+      await executeCommand('docker volume prune -f');
+    } else if (deploymentType === 'kubernetes') {
+      // Kubernetes teardown
+      await executeCommand('kubectl delete -f kubernetes/test-environment.yaml --namespace test');
+      await executeCommand('kubectl delete namespace test');
+    } else if (deploymentType === 'cloud') {
+      // Cloud infrastructure teardown
+      const envDetailsPath = path.join('environments', `${envName}.json`);
+      if (fs.existsSync(envDetailsPath)) {
+        const envDetails = JSON.parse(fs.readFileSync(envDetailsPath, 'utf8'));
+        await teardownCloudEnvironment(envDetails);
+        fs.unlinkSync(envDetailsPath);
+      }
+    }
+    
+    // Cleanup local artifacts
+    await executeCommand('rm -rf test-results/ videos/ logs/');
+    
+    console.log('Environment teardown completed successfully');
+    
+  } catch (error) {
+    console.error('Error during environment teardown:', error);
+    throw error;
+  }
+}
+
+function executeCommand(command) {
+  return new Promise((resolve, reject) => {
+    exec(command, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      if (stderr) {
+        console.error('Command stderr:', stderr);
+      }
+      resolve(stdout);
+    });
+  });
+}
+
+async function teardownCloudEnvironment(envDetails) {
+  // Implementation for tearing down cloud resources
+  // Remove VPC, EC2 instances, RDS, ElastiCache, etc.
+  console.log('Tearing down cloud environment...');
+  // Cloud provider specific teardown logic
+}
+
+// Register cleanup on process exit
+process.on('SIGINT', async () => {
+  await teardownEnvironment();
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  await teardownEnvironment();
+  process.exit(0);
+});
+
+module.exports = { teardownEnvironment };