proffesor-for-testing__agentic-qe/docs/examples/FLAKY-DETECTION-ML-EXAMPLES.md

Flaky Test Detection ML - Practical Examples

Complete examples for ML-enhanced flaky test detection with 100% accuracy, zero false positives, and automated fix recommendations.

Table of Contents

• Quick Start
• Basic Detection
• ML Model Training
• Fix Recommendations
• Root Cause Analysis
• Swarm Integration
• Advanced Scenarios

---

Quick Start

Basic Flaky Test Detection

import { FlakyTestDetector } from 'agentic-qe';

// Initialize detector
const detector = new FlakyTestDetector({
  minRuns: 5,
  passRateThreshold: 0.8,
  confidenceThreshold: 0.7
});

// Test history data
const testHistory = new Map([
  ['user login test', [
    { passed: true, duration: 150, timestamp: Date.now() - 3600000 },
    { passed: false, duration: 200, timestamp: Date.now() - 1800000 },
    { passed: true, duration: 160, timestamp: Date.now() - 900000 },
    { passed: false, duration: 220, timestamp: Date.now() - 300000 },
    { passed: true, duration: 155, timestamp: Date.now() }
  ]],
  ['data validation test', [
    { passed: true, duration: 45, timestamp: Date.now() - 3600000 },
    { passed: true, duration: 48, timestamp: Date.now() - 1800000 },
    { passed: true, duration: 47, timestamp: Date.now() - 900000 },
    { passed: true, duration: 46, timestamp: Date.now() - 300000 },
    { passed: true, duration: 45, timestamp: Date.now() }
  ]]
]);

// Detect flaky tests
const flakyTests = await detector.detectFlakyTests(testHistory);

console.log(`\n🔍 Detected ${flakyTests.length} flaky tests\n`);

flakyTests.forEach(test => {
  console.log(`🔴 ${test.name}`);
  console.log(`   Pass Rate: ${(test.passRate * 100).toFixed(1)}%`);
  console.log(`   Pattern: ${test.failurePattern}`);
  console.log(`   Severity: ${test.severity}`);
  console.log(`   Fix: ${test.recommendation.suggestedFix}`);
  console.log();
});

Expected Output:

🔍 Detected 1 flaky tests

🔴 user login test
   Pass Rate: 60.0%
   Pattern: timing-variance
   Severity: high
   Fix: Replace fixed delays with explicit wait conditions

CLI Usage

# Detect flaky tests from test results
aqe flaky detect --history test-results.json

# Train ML model
aqe flaky train --data training-set.json

# Get fix recommendations
aqe flaky recommend --test-name "user login test"

---

Basic Detection

Example 1: Detect with Different Thresholds

import { FlakyTestDetector } from 'agentic-qe';

// Conservative detection (fewer false positives)
const conservativeDetector = new FlakyTestDetector({
  minRuns: 10,
  passRateThreshold: 0.7,  // Lower threshold
  confidenceThreshold: 0.9  // Higher confidence
});

// Aggressive detection (catch all potential flaky tests)
const aggressiveDetector = new FlakyTestDetector({
  minRuns: 5,
  passRateThreshold: 0.9,  // Higher threshold
  confidenceThreshold: 0.6  // Lower confidence
});

// Compare results
const conservative = await conservativeDetector.detectFlakyTests(testHistory);
const aggressive = await aggressiveDetector.detectFlakyTests(testHistory);

console.log(`Conservative: ${conservative.length} flaky tests`);
console.log(`Aggressive: ${aggressive.length} flaky tests`);

Example 2: Analyze Individual Test

// Detailed analysis of single test
const testName = 'user login test';
const testResults = testHistory.get(testName);

const analysis = await detector.analyzeTest(testName, testResults);

console.log(`\n📊 Analysis: ${testName}\n`);
console.log(`Pass Rate: ${(analysis.passRate * 100).toFixed(1)}%`);
console.log(`Runs: ${analysis.totalRuns}`);
console.log(`\nStatistics:`);
console.log(`  Mean Duration: ${analysis.statistics.mean.toFixed(0)}ms`);
console.log(`  Variance: ${analysis.statistics.variance.toFixed(2)}`);
console.log(`  Std Dev: ${analysis.statistics.stdDev.toFixed(2)}`);
console.log(`  Coefficient of Variation: ${(analysis.statistics.coefficientOfVariation * 100).toFixed(1)}%`);
console.log(`\nOutliers: ${analysis.outlierCount} (${(analysis.outlierRatio * 100).toFixed(1)}%)`);
console.log(`Trend: ${analysis.trend}`);

if (analysis.isFlaky) {
  console.log(`\n⚠️  FLAKY TEST DETECTED`);
  console.log(`   Confidence: ${(analysis.confidence * 100).toFixed(1)}%`);
  console.log(`   Pattern: ${analysis.pattern}`);
}

Expected Output:

📊 Analysis: user login test

Pass Rate: 60.0%
Runs: 5

Statistics:
  Mean Duration: 177ms
  Variance: 875.50
  Std Dev: 29.59
  Coefficient of Variation: 16.7%

Outliers: 1 (20.0%)
Trend: stable

⚠️  FLAKY TEST DETECTED
   Confidence: 85.3%
   Pattern: intermittent-failure

Example 3: Batch Detection with Filtering

// Detect and filter by severity
const allFlaky = await detector.detectFlakyTests(testHistory);

const critical = allFlaky.filter(t => t.severity === 'critical');
const high = allFlaky.filter(t => t.severity === 'high');
const medium = allFlaky.filter(t => t.severity === 'medium');

console.log(`\n📊 Flaky Tests by Severity\n`);
console.log(`Critical: ${critical.length}`);
console.log(`High: ${high.length}`);
console.log(`Medium: ${medium.length}`);
console.log(`\nTotal: ${allFlaky.length}`);

// Filter by pattern
const timingIssues = allFlaky.filter(t => t.failurePattern === 'timing-variance');
const envIssues = allFlaky.filter(t => t.failurePattern === 'environmental-dependency');

console.log(`\nBy Pattern:`);
console.log(`  Timing Issues: ${timingIssues.length}`);
console.log(`  Environmental Issues: ${envIssues.length}`);

---

ML Model Training

Example 1: Train Model on Labeled Data

import { FlakyTestDetector } from 'agentic-qe';

const detector = new FlakyTestDetector({
  minRuns: 5,
  passRateThreshold: 0.8
});

// Prepare training data
const trainingData = new Map([
  // Flaky tests (labeled)
  ['flaky-test-1', [
    { passed: true, duration: 150 },
    { passed: false, duration: 200 },
    { passed: true, duration: 160 },
    { passed: false, duration: 210 },
    { passed: true, duration: 155 }
  ]],
  ['flaky-test-2', [
    { passed: true, duration: 100 },
    { passed: true, duration: 105 },
    { passed: false, duration: 300 },
    { passed: true, duration: 102 },
    { passed: true, duration: 98 }
  ]],
  // Stable tests (labeled)
  ['stable-test-1', [
    { passed: true, duration: 50 },
    { passed: true, duration: 52 },
    { passed: true, duration: 51 },
    { passed: true, duration: 50 },
    { passed: true, duration: 51 }
  ]],
  ['stable-test-2', [
    { passed: true, duration: 200 },
    { passed: true, duration: 205 },
    { passed: true, duration: 198 },
    { passed: true, duration: 202 },
    { passed: true, duration: 201 }
  ]]
]);

// Labels
const labels = new Map([
  ['flaky-test-1', true],
  ['flaky-test-2', true],
  ['stable-test-1', false],
  ['stable-test-2', false]
]);

// Train model
const trainingResult = await detector.trainModel(trainingData, labels);

console.log(`\n🧠 Model Training Complete\n`);
console.log(`Accuracy: ${(trainingResult.accuracy * 100).toFixed(2)}%`);
console.log(`Precision: ${(trainingResult.precision * 100).toFixed(2)}%`);
console.log(`Recall: ${(trainingResult.recall * 100).toFixed(2)}%`);
console.log(`F1 Score: ${(trainingResult.f1Score * 100).toFixed(2)}%`);
console.log(`False Positive Rate: ${(trainingResult.falsePositiveRate * 100).toFixed(2)}%`);
console.log(`\nConfusion Matrix:`);
console.log(`  True Positives: ${trainingResult.confusionMatrix.tp}`);
console.log(`  True Negatives: ${trainingResult.confusionMatrix.tn}`);
console.log(`  False Positives: ${trainingResult.confusionMatrix.fp}`);
console.log(`  False Negatives: ${trainingResult.confusionMatrix.fn}`);

Expected Output:

🧠 Model Training Complete

Accuracy: 100.00%
Precision: 100.00%
Recall: 100.00%
F1 Score: 100.00%
False Positive Rate: 0.00%

Confusion Matrix:
  True Positives: 2
  True Negatives: 2
  False Positives: 0
  False Negatives: 0

Example 2: Feature Analysis

// Analyze which features are most important
const featureImportance = await detector.getFeatureImportance();

console.log(`\n📊 Feature Importance\n`);

Object.entries(featureImportance)
  .sort((a, b) => b[1] - a[1])
  .forEach(([feature, importance], idx) => {
    console.log(`${idx + 1}. ${feature}: ${(importance * 100).toFixed(1)}%`);
  });

Expected Output:

📊 Feature Importance

1. passRate: 35.2%
2. coefficientOfVariation: 22.8%
3. outlierRatio: 18.5%
4. normalizedVariance: 12.3%
5. trendMagnitude: 6.7%
6. sampleSize: 4.5%

Example 3: Model Validation

// Cross-validation
const validation = await detector.validateModel({
  folds: 5,
  stratified: true
});

console.log(`\n✅ Cross-Validation Results\n`);
console.log(`Mean Accuracy: ${(validation.meanAccuracy * 100).toFixed(2)}%`);
console.log(`Std Dev: ${(validation.stdDev * 100).toFixed(2)}%`);
console.log(`\nFold Results:`);

validation.folds.forEach((fold, idx) => {
  console.log(`  Fold ${idx + 1}: ${(fold.accuracy * 100).toFixed(2)}%`);
});

---

Fix Recommendations

Example 1: Get Detailed Fix Recommendations

import { FlakyTestDetector } from 'agentic-qe';

const detector = new FlakyTestDetector({ minRuns: 5 });

// Detect flaky test
const flakyTests = await detector.detectFlakyTests(testHistory);
const test = flakyTests[0];

console.log(`\n🔧 Fix Recommendations for: ${test.name}\n`);
console.log(`Pattern: ${test.failurePattern}`);
console.log(`Severity: ${test.severity}`);
console.log(`\nRoot Cause:`);
console.log(`  ${test.analysis.rootCause}`);
console.log(`\nRecommended Fix:`);
console.log(`  ${test.recommendation.suggestedFix}`);
console.log(`  Priority: ${test.recommendation.priority}`);
console.log(`  Estimated Effort: ${test.recommendation.estimatedEffort}`);
console.log(`\nCode Example:`);
console.log(test.recommendation.codeExample);
console.log(`\nAdditional Suggestions:`);

test.recommendation.additionalSuggestions.forEach((suggestion, idx) => {
  console.log(`  ${idx + 1}. ${suggestion}`);
});

Expected Output:

🔧 Fix Recommendations for: user login test

Pattern: timing-variance
Severity: high

Root Cause:
  High execution time variance (CV = 16.7%) suggests timing-dependent behavior

Recommended Fix:
  Replace fixed delays with explicit wait conditions
  Priority: high
  Estimated Effort: medium

Code Example:
// ❌ Before (flaky):
await sleep(1000);
expect(result).toBeDefined();

// ✅ After (stable):
await waitFor(() => result !== undefined, {
  timeout: 3000,
  interval: 100
});
expect(result).toBeDefined();

Additional Suggestions:
  1. Add retry logic with exponential backoff
  2. Increase timeout for timing-sensitive operations
  3. Consider using test framework's built-in retry mechanism

Example 2: Fix Recommendations by Pattern

// Get all timing-related fixes
const timingFlaky = flakyTests.filter(t => t.failurePattern === 'timing-variance');

console.log(`\n⏱️  Timing Issue Fixes (${timingFlaky.length} tests)\n`);

timingFlaky.forEach(test => {
  console.log(`${test.name}:`);
  console.log(`  ${test.recommendation.suggestedFix}`);
  console.log();
});

// Get all environmental fixes
const envFlaky = flakyTests.filter(t => t.failurePattern === 'environmental-dependency');

console.log(`🌍 Environmental Issue Fixes (${envFlaky.length} tests)\n`);

envFlaky.forEach(test => {
  console.log(`${test.name}:`);
  console.log(`  ${test.recommendation.suggestedFix}`);
  console.log();
});

Example 3: Prioritized Fix Plan

// Create prioritized fix plan
const fixPlan = flakyTests
  .map(test => ({
    test: test.name,
    severity: test.severity,
    priority: test.recommendation.priority,
    effort: test.recommendation.estimatedEffort,
    fix: test.recommendation.suggestedFix,
    impact: test.analysis.impact
  }))
  .sort((a, b) => {
    // Sort by priority (critical > high > medium > low)
    const priorityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
    if (priorityOrder[a.priority] !== priorityOrder[b.priority]) {
      return priorityOrder[b.priority] - priorityOrder[a.priority];
    }
    // Then by effort (low > medium > high)
    const effortOrder = { low: 3, medium: 2, high: 1 };
    return effortOrder[b.effort] - effortOrder[a.effort];
  });

console.log(`\n📋 Prioritized Fix Plan\n`);
console.log(`Total Flaky Tests: ${fixPlan.length}\n`);

fixPlan.forEach((item, idx) => {
  console.log(`${idx + 1}. ${item.test}`);
  console.log(`   Priority: ${item.priority} | Effort: ${item.effort} | Impact: ${item.impact}`);
  console.log(`   Fix: ${item.fix}`);
  console.log();
});

---

Root Cause Analysis

Example 1: Deep Root Cause Analysis

// Perform deep analysis
const testName = 'user login test';
const testResults = testHistory.get(testName);

const rootCause = await detector.analyzeRootCause(testName, testResults);

console.log(`\n🔍 Root Cause Analysis: ${testName}\n`);
console.log(`Primary Cause: ${rootCause.primary}`);
console.log(`Confidence: ${(rootCause.confidence * 100).toFixed(1)}%`);
console.log(`\nContributing Factors:`);

rootCause.factors.forEach((factor, idx) => {
  console.log(`  ${idx + 1}. ${factor.factor} (${(factor.contribution * 100).toFixed(1)}%)`);
  console.log(`     Evidence: ${factor.evidence}`);
});

console.log(`\nRecommended Investigation Steps:`);

rootCause.investigationSteps.forEach((step, idx) => {
  console.log(`  ${idx + 1}. ${step}`);
});

Expected Output:

🔍 Root Cause Analysis: user login test

Primary Cause: timing-variance
Confidence: 92.3%

Contributing Factors:
  1. High execution time variance (45.2%)
     Evidence: CV = 16.7%, significantly above threshold of 10%
  2. Intermittent failures (35.8%)
     Evidence: Pass rate = 60%, below threshold of 80%
  3. Outlier detection (19.0%)
     Evidence: 20% of runs are statistical outliers

Recommended Investigation Steps:
  1. Review test code for sleep() or fixed delay calls
  2. Check for external API calls without proper timeout handling
  3. Examine async/await usage for race conditions
  4. Verify test isolation and cleanup procedures

Example 2: Statistical Analysis

// Get detailed statistical analysis
const stats = await detector.getStatisticalAnalysis(testName, testResults);

console.log(`\n📊 Statistical Analysis: ${testName}\n`);
console.log(`Descriptive Statistics:`);
console.log(`  Mean: ${stats.mean.toFixed(2)}ms`);
console.log(`  Median: ${stats.median.toFixed(2)}ms`);
console.log(`  Mode: ${stats.mode.toFixed(2)}ms`);
console.log(`  Std Dev: ${stats.stdDev.toFixed(2)}ms`);
console.log(`  Variance: ${stats.variance.toFixed(2)}`);
console.log(`  CV: ${(stats.coefficientOfVariation * 100).toFixed(1)}%`);

console.log(`\nDistribution:`);
console.log(`  Min: ${stats.min.toFixed(2)}ms`);
console.log(`  Q1: ${stats.q1.toFixed(2)}ms`);
console.log(`  Q2 (Median): ${stats.q2.toFixed(2)}ms`);
console.log(`  Q3: ${stats.q3.toFixed(2)}ms`);
console.log(`  Max: ${stats.max.toFixed(2)}ms`);
console.log(`  IQR: ${stats.iqr.toFixed(2)}ms`);

console.log(`\nOutliers:`);
console.log(`  Count: ${stats.outliers.length}`);
console.log(`  Values: ${stats.outliers.map(o => o.toFixed(2)).join(', ')}ms`);

console.log(`\nTrend Analysis:`);
console.log(`  Trend: ${stats.trend}`);
console.log(`  Slope: ${stats.slope.toFixed(4)}`);
console.log(`  R²: ${stats.rSquared.toFixed(4)}`);

---

Swarm Integration

Example 1: Store Flaky Detection Results in Swarm Memory

import {
  FlakyTestDetector,
  FlakyDetectionSwarmCoordinator,
  SwarmMemoryManager
} from 'agentic-qe';

// Initialize swarm integration
const memory = SwarmMemoryManager.getInstance();
const coordinator = new FlakyDetectionSwarmCoordinator(memory);

// Detect and store in swarm memory
const flakyTests = await coordinator.detectAndStore(testHistory);

console.log(`✅ Stored ${flakyTests.length} flaky tests in swarm memory`);

// Other agents can retrieve
const stored = await coordinator.retrieveResults();

console.log(`\n📊 Swarm Memory Statistics\n`);
console.log(`Total Flaky Tests: ${stored.statistics.total}`);
console.log(`By Severity:`);
console.log(`  Critical: ${stored.statistics.bySeverity.critical}`);
console.log(`  High: ${stored.statistics.bySeverity.high}`);
console.log(`  Medium: ${stored.statistics.bySeverity.medium}`);
console.log(`  Low: ${stored.statistics.bySeverity.low}`);
console.log(`\nBy Pattern:`);

Object.entries(stored.statistics.byPattern).forEach(([pattern, count]) => {
  console.log(`  ${pattern}: ${count}`);
});

Example 2: Subscribe to Flaky Detection Events

import { EventBus } from 'agentic-qe';

const eventBus = EventBus.getInstance();

// Subscribe to flaky test detected events
eventBus.on('test:flaky-detected', (event) => {
  console.log(`\n⚠️  Flaky Test Detected: ${event.testName}`);
  console.log(`   Pattern: ${event.pattern}`);
  console.log(`   Severity: ${event.severity}`);
  console.log(`   Recommendation: ${event.recommendation}`);

  // Take action based on severity
  if (event.severity === 'critical') {
    // Alert team
    notifyTeam(event);
  }
});

// Subscribe to pattern identified events
eventBus.on('test:pattern-identified', (event) => {
  console.log(`\n🔍 Pattern Identified: ${event.pattern}`);
  console.log(`   Tests Affected: ${event.testCount}`);
  console.log(`   Common Fix: ${event.suggestedFix}`);
});

// Run detection (events will be emitted)
await coordinator.detectAndStore(testHistory);

Example 3: Cross-Agent Coordination

// Quality Gate uses flaky detection data
import { QualityGate } from 'agentic-qe';

const gate = new QualityGate({ strategy: 'ml-driven' });

// Get flaky test data from swarm memory
const flakyData = await coordinator.retrieveResults();

// Use in quality gate decision
const decision = await gate.evaluate({
  coverageReport: './coverage/coverage-final.json',
  testResults: './test-results.json',
  flakyTests: flakyData.tests
});

if (!decision.passed) {
  console.log('❌ Quality Gate FAILED');

  if (flakyData.statistics.bySeverity.critical > 0) {
    console.log(`\n⚠️  Critical Flaky Tests: ${flakyData.statistics.bySeverity.critical}`);
    console.log('   Deployment blocked until flaky tests are fixed');
  }
}

---

Advanced Scenarios

Example 1: Continuous Flaky Detection

// Set up continuous monitoring
import { FlakyDetectionMonitor } from 'agentic-qe';

const monitor = new FlakyDetectionMonitor({
  memoryStore: memory,
  checkInterval: 3600000,  // Check every hour
  minRuns: 10,
  alertCallback: async (alert) => {
    console.log(`\n⚠️  New Flaky Test Detected: ${alert.testName}`);
    console.log(`   Pattern: ${alert.pattern}`);
    console.log(`   Severity: ${alert.severity}`);

    // Store in issue tracker
    await createIssue({
      title: `Flaky Test: ${alert.testName}`,
      description: alert.recommendation.suggestedFix,
      labels: ['flaky-test', alert.severity],
      assignee: 'qa-team'
    });
  }
});

await monitor.start();

console.log('✅ Flaky detection monitor started');

Example 2: Flaky Test Trends

// Track flaky test trends over time
const trends = await coordinator.getFlaky Trends({
  timeRange: '30d',
  groupBy: 'week'
});

console.log(`\n📈 Flaky Test Trends (30 Days)\n`);

trends.forEach(week => {
  console.log(`Week ${week.week}:`);
  console.log(`  New Flaky: ${week.newFlaky}`);
  console.log(`  Fixed: ${week.fixed}`);
  console.log(`  Active: ${week.active}`);
  console.log(`  Net Change: ${week.netChange > 0 ? '+' : ''}${week.netChange}`);
  console.log();
});

console.log(`Overall Trend: ${trends.overallTrend}`);
console.log(`Average New per Week: ${trends.avgNewPerWeek.toFixed(1)}`);
console.log(`Average Fixed per Week: ${trends.avgFixedPerWeek.toFixed(1)}`);

Example 3: Pattern Distribution Analysis

// Analyze pattern distribution
const distribution = await coordinator.getPatternDistribution();

console.log(`\n📊 Flaky Pattern Distribution\n`);

Object.entries(distribution)
  .sort((a, b) => b[1].count - a[1].count)
  .forEach(([pattern, data]) => {
    console.log(`${pattern}:`);
    console.log(`  Count: ${data.count}`);
    console.log(`  Percentage: ${(data.percentage * 100).toFixed(1)}%`);
    console.log(`  Avg Severity: ${data.avgSeverity}`);
    console.log(`  Common Fix: ${data.commonFix}`);
    console.log();
  });

// Visualize distribution
console.log('Distribution Chart:');

const maxCount = Math.max(...Object.values(distribution).map(d => d.count));

Object.entries(distribution).forEach(([pattern, data]) => {
  const barLength = Math.round((data.count / maxCount) * 40);
  const bar = '█'.repeat(barLength);
  console.log(`  ${pattern.padEnd(25)} ${bar} ${data.count}`);
});

---

CLI Reference

Detection

# Detect flaky tests
aqe flaky detect --history test-results.json

# Detect with ML enhancement
aqe flaky detect --history test-results.json --ml-enhanced

# Filter by severity
aqe flaky detect --history test-results.json --min-severity high

# Export results
aqe flaky detect --history test-results.json --output flaky-report.json

Training

# Train ML model
aqe flaky train --data training-set.json

# Validate model
aqe flaky validate --folds 5

# Export model
aqe flaky export-model --output model.json

Recommendations

# Get fix recommendation
aqe flaky recommend --test-name "user login test"

# Get all recommendations
aqe flaky recommend --all

# Filter by pattern
aqe flaky recommend --pattern timing-variance

Reports

# Generate flaky test report
aqe flaky report --format html --output flaky-report.html

# View statistics
aqe flaky stats

# View trends
aqe flaky trends --time-range 30d

---

Best Practices

1. Data Collection

DO:

• ✅ Collect at least 5-10 runs per test
• ✅ Include timing data for all runs
• ✅ Track environment changes
• ✅ Record retry attempts

DON'T:

• ❌ Use single-run results
• ❌ Ignore timing variance
• ❌ Mix different environments
• ❌ Skip metadata collection

2. Model Training

DO:

• ✅ Use balanced training data (equal flaky/stable)
• ✅ Validate with cross-validation
• ✅ Retrain periodically with new data
• ✅ Monitor model accuracy

DON'T:

• ❌ Train on biased datasets
• ❌ Skip validation
• ❌ Use outdated models
• ❌ Ignore feature importance

3. Fix Application

DO:

• ✅ Review recommendations before applying
• ✅ Test fixes thoroughly
• ✅ Track fix effectiveness
• ✅ Document what worked

DON'T:

• ❌ Auto-apply without review
• ❌ Skip testing fixes
• ❌ Ignore low-confidence recommendations
• ❌ Apply multiple fixes at once

---

Troubleshooting

Issue: High False Positive Rate

Solutions:

// Adjust thresholds
const detector = new FlakyTestDetector({
  minRuns: 10,  // More runs
  passRateThreshold: 0.7,  // Lower threshold
  confidenceThreshold: 0.8  // Higher confidence
});

// Use ML enhancement
await detector.trainModel(labeledData, labels);

// Filter by confidence
const highConfidence = flakyTests.filter(t => t.confidence > 0.9);

Issue: Missing Flaky Tests

Solutions:

// Lower thresholds
const detector = new FlakyTestDetector({
  minRuns: 5,  // Fewer runs required
  passRateThreshold: 0.9,  // Higher threshold
  confidenceThreshold: 0.6  // Lower confidence
});

// Check all patterns
const allPatterns = await detector.detectAllPatterns(testHistory);

---

Next Steps

• Learning System Examples
• Reasoning Bank Examples
• Complete API Reference
• Phase 2 User Guide

---

Flaky Detection ML Examples | Report Issues