diff --git a/docs/retry-mechanisms-enhancement.md b/docs/retry-mechanisms-enhancement.md
index c30874925..9634e74af 100644
--- a/docs/retry-mechanisms-enhancement.md
+++ b/docs/retry-mechanisms-enhancement.md
@@ -1,122 +1,50 @@
-# Retry Mechanisms Enhancement
+# Retry Mechanisms
 
-This document describes the improvements made to CodeceptJS retry mechanisms to eliminate overlaps and provide better coordination.
+This document describes the retry coordination system in CodeceptJS.
 
 ## Problem Statement
 
-CodeceptJS previously had multiple retry mechanisms that could overlap and conflict:
+CodeceptJS has multiple retry mechanisms at different levels:
 
 1. **Global Retry Configuration** - Feature and Scenario level retries
 2. **RetryFailedStep Plugin** - Individual step retries
 3. **Manual Step Retries** - `I.retry()` calls
 4. **Hook Retries** - Before/After hook retries
-5. **Helper Retries** - Helper-specific retry mechanisms
 
 These mechanisms could result in:
 
 - Exponential retry counts (e.g., 3 scenario retries × 2 step retries = 6 total executions per step)
 - Conflicting configurations with no clear precedence
-- Confusing logging and unclear behavior
-- Difficult debugging when multiple retry levels were active
 
 ## Solution Overview
 
-### 1. Enhanced Global Retry (`lib/listener/enhancedGlobalRetry.js`)
+CodeceptJS now includes a priority-based coordination system to prevent conflicts.
 
-**New Features:**
-
-- Priority-based retry coordination
-- Clear precedence system
-- Enhanced logging with mechanism identification
-- Backward compatibility with existing configurations
-
-**Priority System:**
+### Priority System
 
 ```javascript
 const RETRY_PRIORITIES = {
-  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
-  STEP_PLUGIN: 50, // retryFailedStep plugin
-  SCENARIO_CONFIG: 30, // Global scenario retry config
-  FEATURE_CONFIG: 20, // Global feature retry config
-  HOOK_CONFIG: 10, // Hook retry config - lowest priority
+  MANUAL_STEP: 100,      // I.retry() or step.retry() - highest priority
+  STEP_PLUGIN: 50,       // retryFailedStep plugin
+  SCENARIO_CONFIG: 30,   // Global scenario retry config
+  FEATURE_CONFIG: 20,    // Global feature retry config
+  HOOK_CONFIG: 10,       // Hook retry config - lowest priority
 }
 ```
 
-### 2. Enhanced RetryFailedStep Plugin (`lib/plugin/enhancedRetryFailedStep.js`)
-
-**New Features:**
-
-- Automatic coordination with scenario-level retries
-- Smart deferral when scenario retries are configured
-- Priority-aware retry registration
-- Improved logging and debugging information
-
-**Coordination Logic:**
-
-- When scenario retries are configured, step retries are automatically deferred to avoid excessive retry counts
-- Users can override this with `deferToScenarioRetries: false`
-- Clear logging explains coordination decisions
-
-### 3. Retry Coordinator (`lib/retryCoordinator.js`)
-
-**New Features:**
-
-- Central coordination service for all retry mechanisms
-- Configuration validation with warnings for potential conflicts
-- Retry registration and priority management
-- Summary reporting for debugging
-
-**Key Functions:**
-
-- `validateConfig()` - Detects configuration conflicts and excessive retry counts
-- `registerRetry()` - Registers retry mechanisms with priority coordination
-- `getEffectiveRetryConfig()` - Returns the active retry configuration for a target
-- `generateRetrySummary()` - Provides debugging information about active retry mechanisms
-
-## Migration Guide
-
-### Immediate Benefits (No Changes Needed)
-
-The enhanced retry mechanisms are **backward compatible**. Existing configurations will continue to work with these improvements:
-
-- Better coordination between retry mechanisms
-- Enhanced logging for debugging
-- Automatic conflict detection and resolution
-
-### Recommended Configuration Updates
+Higher priority retries will not be overwritten by lower priority ones.
 
-#### 1. For Simple Cases - Use Scenario Retries Only
+## Configuration Examples
 
-**Old Configuration (potentially conflicting):**
+### Scenario Retries Only
 
 ```javascript
 module.exports = {
   retry: 3, // scenario retries
-  plugins: {
-    retryFailedStep: {
-      enabled: true,
-      retries: 2, // step retries - could result in 3 * 3 = 9 executions
-    },
-  },
-}
-```
-
-**Recommended Configuration:**
-
-```javascript
-module.exports = {
-  retry: 3, // scenario retries only
-  plugins: {
-    retryFailedStep: {
-      enabled: false, // disable to avoid conflicts
-    },
-  },
 }
 ```
 
-#### 2. For Step-Level Control - Use Step Retries Only
-
-**Recommended Configuration:**
+### Step Retries Only
 
 ```javascript
 module.exports = {
@@ -124,114 +52,40 @@ module.exports = {
     retryFailedStep: {
       enabled: true,
       retries: 2,
-      ignoredSteps: ['amOnPage', 'wait*'], // customize as needed
+      ignoredSteps: ['amOnPage', 'wait*'],
     },
   },
-  // No global retry configuration
 }
 ```
 
-#### 3. For Mixed Scenarios - Use Enhanced Coordination
+### Mixed - With Auto Coordination
 
 ```javascript
 module.exports = {
   retry: {
-    Scenario: 2, // scenario retries for most tests
+    Scenario: 2, // scenario retries
   },
   plugins: {
     retryFailedStep: {
       enabled: true,
       retries: 1,
-      deferToScenarioRetries: true, // automatically coordinate (default)
+      deferToScenarioRetries: true, // auto-coordinate (default)
     },
   },
 }
 ```
 
-### Testing Your Configuration
-
-Use the new retry coordinator to validate your configuration:
-
-```javascript
-const retryCoordinator = require('codeceptjs/lib/retryCoordinator')
-
-// Validate your configuration
-const warnings = retryCoordinator.validateConfig(yourConfig)
-if (warnings.length > 0) {
-  console.log('Retry configuration warnings:')
-  warnings.forEach(warning => console.log('  -', warning))
-}
-```
-
-## Enhanced Logging
-
-The new retry mechanisms provide clearer logging:
-
-```
-[Global Retry] Scenario retries: 3
-[Step Retry] Deferred to scenario retries (3 retries)
-[Retry Coordinator] Registered scenario retry (priority: 30)
-```
-
-## Breaking Changes
-
-**None.** All existing configurations continue to work.
+**Important:** When `deferToScenarioRetries` is true (default), step retries are automatically disabled if scenario retries are configured to avoid excessive total retries (2 scenario × 3 step = 6 executions per step).
 
 ## New Configuration Options
 
-### Enhanced RetryFailedStep Plugin
-
-```javascript
-plugins: {
-  retryFailedStep: {
-    enabled: true,
-    retries: 2,
-    deferToScenarioRetries: true, // NEW: automatically coordinate with scenario retries
-    minTimeout: 1000,
-    maxTimeout: 10000,
-    factor: 1.5,
-    ignoredSteps: ['wait*', 'amOnPage']
-  }
-}
-```
-
-### New Options:
+### retryFailedStep Plugin
 
 - `deferToScenarioRetries` (boolean, default: true) - When true, step retries are disabled if scenario retries are configured
 
-## Debugging Retry Issues
-
-### 1. Check Configuration Validation
-
-```javascript
-const retryCoordinator = require('codeceptjs/lib/retryCoordinator')
-const warnings = retryCoordinator.validateConfig(Config.get())
-console.log('Configuration warnings:', warnings)
-```
-
-### 2. Monitor Enhanced Logging
-
-Run tests with `--verbose` to see detailed retry coordination logs.
-
-### 3. Generate Retry Summary
-
-```javascript
-// In your test hooks
-const summary = retryCoordinator.generateRetrySummary()
-console.log('Retry mechanisms active:', summary)
-```
-
 ## Best Practices
 
-1. **Choose One Primary Retry Strategy** - Either scenario-level OR step-level retries, not both
-2. **Use Configuration Validation** - Check for conflicts before running tests
-3. **Monitor Retry Logs** - Use enhanced logging to understand retry behavior
-4. **Test Retry Behavior** - Verify your retry configuration works as expected
-5. **Avoid Excessive Retries** - High retry counts often indicate test stability issues
-
-## Future Enhancements
-
-- Integration with retry coordinator for all retry mechanisms
-- Runtime retry strategy adjustment
-- Retry analytics and reporting
-- Advanced retry patterns (exponential backoff, conditional retries)
+1. **Choose One Primary Retry Strategy** - Either scenario-level OR step-level retries
+2. **Use Auto Coordination** - Enable `deferToScenarioRetries` to avoid conflicts
+3. **Monitor Retry Behavior** - Use `DEBUG_RETRY_PLUGIN=1` to see retry details
+4. **Avoid Excessive Retries** - High retry counts often indicate test stability issues
diff --git a/lib/listener/enhancedGlobalRetry.js b/lib/listener/enhancedGlobalRetry.js
deleted file mode 100644
index 2c419039c..000000000
--- a/lib/listener/enhancedGlobalRetry.js
+++ /dev/null
@@ -1,110 +0,0 @@
-import event from '../event.js'
-import output from '../output.js'
-import Config from '../config.js'
-import { isNotSet } from '../utils.js'
-
-const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
-
-/**
- * Priority levels for retry mechanisms (higher number = higher priority)
- * This ensures consistent behavior when multiple retry mechanisms are active
- */
-const RETRY_PRIORITIES = {
-  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
-  STEP_PLUGIN: 50, // retryFailedStep plugin
-  SCENARIO_CONFIG: 30, // Global scenario retry config
-  FEATURE_CONFIG: 20, // Global feature retry config
-  HOOK_CONFIG: 10, // Hook retry config - lowest priority
-}
-
-/**
- * Enhanced global retry mechanism that coordinates with other retry types
- */
-export default function () {
-  event.dispatcher.on(event.suite.before, suite => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
-
-    if (Number.isInteger(+retryConfig)) {
-      // is number - apply as feature-level retry
-      const retryNum = +retryConfig
-      output.log(`[Global Retry] Feature retries: ${retryNum}`)
-
-      // Only set if not already set by higher priority mechanism
-      if (isNotSet(suite.retries())) {
-        suite.retries(retryNum)
-        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
-      }
-      return
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
-    }
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!suite.title.includes(config.grep)) continue
-      }
-
-      // Handle hook retries with priority awareness
-      hooks
-        .filter(hook => !!config[hook])
-        .forEach(hook => {
-          const retryKey = `retry${hook}`
-          if (isNotSet(suite.opts[retryKey])) {
-            suite.opts[retryKey] = config[hook]
-            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
-          }
-        })
-
-      // Handle feature-level retries
-      if (config.Feature) {
-        if (isNotSet(suite.retries()) || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
-          suite.retries(config.Feature)
-          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
-          output.log(`[Global Retry] Feature retries: ${config.Feature}`)
-        }
-      }
-    }
-  })
-
-  event.dispatcher.on(event.test.before, test => {
-    let retryConfig = Config.get('retry')
-    if (!retryConfig) return
-
-    if (Number.isInteger(+retryConfig)) {
-      // Only set if not already set by higher priority mechanism
-      if (test.retries() === -1) {
-        test.retries(retryConfig)
-        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
-        output.log(`[Global Retry] Scenario retries: ${retryConfig}`)
-      }
-      return
-    }
-
-    if (!Array.isArray(retryConfig)) {
-      retryConfig = [retryConfig]
-    }
-
-    retryConfig = retryConfig.filter(config => !!config.Scenario)
-
-    for (const config of retryConfig) {
-      if (config.grep) {
-        if (!test.fullTitle().includes(config.grep)) continue
-      }
-
-      if (config.Scenario) {
-        // Respect priority system
-        if (test.retries() === -1 || (test.opts.retryPriority || 0) <= RETRY_PRIORITIES.SCENARIO_CONFIG) {
-          test.retries(config.Scenario)
-          test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
-          output.log(`[Global Retry] Scenario retries: ${config.Scenario}`)
-        }
-      }
-    }
-  })
-}
-
-// Export priority constants for use by other retry mechanisms
-export { RETRY_PRIORITIES }
diff --git a/lib/listener/globalRetry.js b/lib/listener/globalRetry.js
index 13f722298..1a3ee1e93 100644
--- a/lib/listener/globalRetry.js
+++ b/lib/listener/globalRetry.js
@@ -5,16 +5,27 @@ import { isNotSet } from '../utils.js'
 
 const hooks = ['Before', 'After', 'BeforeSuite', 'AfterSuite']
 
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100,
+  STEP_PLUGIN: 50,
+  SCENARIO_CONFIG: 30,
+  FEATURE_CONFIG: 20,
+  HOOK_CONFIG: 10,
+}
+
 export default function () {
   event.dispatcher.on(event.suite.before, suite => {
     let retryConfig = Config.get('retry')
     if (!retryConfig) return
 
     if (Number.isInteger(+retryConfig)) {
-      // is number
       const retryNum = +retryConfig
       output.log(`Retries: ${retryNum}`)
-      suite.retries(retryNum)
+
+      if (suite.retries() === -1 || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+        suite.retries(retryNum)
+        suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+      }
       return
     }
 
@@ -30,11 +41,18 @@ export default function () {
       hooks
         .filter(hook => !!config[hook])
         .forEach(hook => {
-          if (isNotSet(suite.opts[`retry${hook}`])) suite.opts[`retry${hook}`] = config[hook]
+          const retryKey = `retry${hook}`
+          if (isNotSet(suite.opts[retryKey])) {
+            suite.opts[retryKey] = config[hook]
+            suite.opts[`${retryKey}Priority`] = RETRY_PRIORITIES.HOOK_CONFIG
+          }
         })
 
       if (config.Feature) {
-        if (isNotSet(suite.retries())) suite.retries(config.Feature)
+        if (suite.retries() === -1 || (suite.opts.retryPriority || 0) <= RETRY_PRIORITIES.FEATURE_CONFIG) {
+          suite.retries(config.Feature)
+          suite.opts.retryPriority = RETRY_PRIORITIES.FEATURE_CONFIG
+        }
       }
 
       output.log(`Retries: ${JSON.stringify(config)}`)
@@ -46,7 +64,10 @@ export default function () {
     if (!retryConfig) return
 
     if (Number.isInteger(+retryConfig)) {
-      if (test.retries() === -1) test.retries(retryConfig)
+      if (test.retries() === -1) {
+        test.retries(retryConfig)
+        test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+      }
       return
     }
 
@@ -62,9 +83,14 @@ export default function () {
       }
 
       if (config.Scenario) {
-        if (test.retries() === -1) test.retries(config.Scenario)
+        if (test.retries() === -1 || (test.opts.retryPriority || 0) <= RETRY_PRIORITIES.SCENARIO_CONFIG) {
+          test.retries(config.Scenario)
+          test.opts.retryPriority = RETRY_PRIORITIES.SCENARIO_CONFIG
+        }
         output.log(`Retries: ${config.Scenario}`)
       }
     }
   })
 }
+
+export { RETRY_PRIORITIES }
diff --git a/lib/plugin/enhancedRetryFailedStep.js b/lib/plugin/enhancedRetryFailedStep.js
deleted file mode 100644
index dcc318112..000000000
--- a/lib/plugin/enhancedRetryFailedStep.js
+++ /dev/null
@@ -1,99 +0,0 @@
-import event from '../event.js'
-import recorder from '../recorder.js'
-import store from '../store.js'
-import output from '../output.js'
-import { RETRY_PRIORITIES } from '../retryCoordinator.js'
-
-const defaultConfig = {
-  retries: 3,
-  defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
-  factor: 1.5,
-  ignoredSteps: [],
-}
-
-/**
- * Enhanced retryFailedStep plugin that coordinates with other retry mechanisms
- *
- * This plugin provides step-level retries and coordinates with global retry settings
- * to avoid conflicts and provide predictable behavior.
- */
-export default config => {
-  config = Object.assign({}, defaultConfig, config)
-  config.ignoredSteps = config.ignoredSteps.concat(config.defaultIgnoredSteps)
-  const customWhen = config.when
-
-  let enableRetry = false
-
-  const when = err => {
-    if (!enableRetry) return false
-    if (store.debugMode) return false
-    if (!store.autoRetries) return false
-    if (customWhen) return customWhen(err)
-    return true
-  }
-  config.when = when
-
-  event.dispatcher.on(event.step.started, step => {
-    // if a step is ignored - return
-    for (const ignored of config.ignoredSteps) {
-      if (step.name === ignored) return
-      if (ignored instanceof RegExp) {
-        if (step.name.match(ignored)) return
-      } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
-    }
-    enableRetry = true // enable retry for a step
-  })
-
-  event.dispatcher.on(event.step.finished, () => {
-    enableRetry = false
-  })
-
-  event.dispatcher.on(event.test.before, test => {
-    // pass disableRetryFailedStep is a preferred way to disable retries
-    // test.disableRetryFailedStep is used for backward compatibility
-    if (test.opts.disableRetryFailedStep || test.disableRetryFailedStep) {
-      store.autoRetries = false
-      output.log(`[Step Retry] Disabled for test: ${test.title}`)
-      return // disable retry when a test is not active
-    }
-
-    // Check if step retries should be disabled due to higher priority scenario retries
-    const scenarioRetries = test.retries()
-    const stepRetryPriority = RETRY_PRIORITIES.STEP_PLUGIN
-    const scenarioPriority = test.opts.retryPriority || 0
-
-    if (scenarioRetries > 0 && config.deferToScenarioRetries !== false) {
-      // Scenario retries are configured with higher or equal priority
-      // Option 1: Disable step retries (conservative approach)
-      store.autoRetries = false
-      output.log(`[Step Retry] Deferred to scenario retries (${scenarioRetries} retries)`)
-      return
-
-      // Option 2: Reduce step retries to avoid excessive total retries
-      // const reducedStepRetries = Math.max(1, Math.floor(config.retries / scenarioRetries))
-      // config.retries = reducedStepRetries
-      // output.log(`[Step Retry] Reduced to ${reducedStepRetries} retries due to scenario retries (${scenarioRetries})`)
-    }
-
-    // this option is used to set the retries inside _before() block of helpers
-    store.autoRetries = true
-    test.opts.conditionalRetries = config.retries
-    test.opts.stepRetryPriority = stepRetryPriority
-
-    recorder.retry(config)
-
-    output.log(`[Step Retry] Enabled with ${config.retries} retries for test: ${test.title}`)
-  })
-
-  // Add coordination info for debugging
-  event.dispatcher.on(event.test.finished, test => {
-    if (test.state === 'passed' && test.opts.conditionalRetries && store.autoRetries) {
-      const stepRetries = test.opts.conditionalRetries || 0
-      const scenarioRetries = test.retries() || 0
-
-      if (stepRetries > 0 && scenarioRetries > 0) {
-        output.log(`[Retry Coordination] Test used both step retries (${stepRetries}) and scenario retries (${scenarioRetries})`)
-      }
-    }
-  })
-}
diff --git a/lib/plugin/retryFailedStep.js b/lib/plugin/retryFailedStep.js
index 4c1893a4c..e9bcac52e 100644
--- a/lib/plugin/retryFailedStep.js
+++ b/lib/plugin/retryFailedStep.js
@@ -1,7 +1,5 @@
 import event from '../event.js'
-
 import recorder from '../recorder.js'
-
 import store from '../store.js'
 
 const defaultConfig = {
@@ -9,6 +7,15 @@ const defaultConfig = {
   defaultIgnoredSteps: ['amOnPage', 'wait*', 'send*', 'execute*', 'run*', 'have*'],
   factor: 1.5,
   ignoredSteps: [],
+  deferToScenarioRetries: true,
+}
+
+const RETRY_PRIORITIES = {
+  MANUAL_STEP: 100,
+  STEP_PLUGIN: 50,
+  SCENARIO_CONFIG: 30,
+  FEATURE_CONFIG: 20,
+  HOOK_CONFIG: 10,
 }
 
 /**
@@ -49,6 +56,7 @@ const defaultConfig = {
  * * `ignoredSteps` - an array for custom steps to ignore on retry. Use it to append custom steps to ignored list.
  * You can use step names or step prefixes ending with `*`. As such, `wait*` will match all steps starting with `wait`.
  * To append your own steps to ignore list - copy and paste a default steps list. Regexp values are accepted as well.
+ * * `deferToScenarioRetries` - when enabled (default), step retries are automatically disabled if scenario retries are configured to avoid excessive total retries.
  *
  * #### Example
  *
@@ -88,73 +96,74 @@ export default function (config) {
     if (!enableRetry) return
     if (store.debugMode) return false
     if (!store.autoRetries) return false
-    // Don't retry terminal errors (e.g., frame detachment errors)
     if (err && err.isTerminal) return false
-    // Don't retry navigation errors that are known to be terminal
     if (err && err.message && (err.message.includes('ERR_ABORTED') || err.message.includes('frame was detached') || err.message.includes('Target page, context or browser has been closed'))) return false
     if (customWhen) return customWhen(err)
     return true
   }
   config.when = when
 
-  // Ensure retry options are available before any steps run
   if (!recorder.retries.find(r => r === config)) {
     recorder.retries.push(config)
   }
 
   event.dispatcher.on(event.step.started, step => {
-    // if a step is ignored - return
     for (const ignored of config.ignoredSteps) {
       if (step.name === ignored) return
       if (ignored instanceof RegExp) {
         if (step.name.match(ignored)) return
       } else if (ignored.indexOf('*') && step.name.startsWith(ignored.slice(0, -1))) return
     }
-    enableRetry = true // enable retry for a step
+    enableRetry = true
   })
 
-  // Disable retry only after a successful step; keep it enabled for failure so retry logic can act
   event.dispatcher.on(event.step.passed, () => {
     enableRetry = false
   })
 
   event.dispatcher.on(event.test.before, test => {
-    // pass disableRetryFailedStep is a preferred way to disable retries
-    // test.disableRetryFailedStep is used for backward compatibility
     if (!test.opts) test.opts = {}
     if (test.opts.disableRetryFailedStep || test.disableRetryFailedStep) {
       store.autoRetries = false
-      return // disable retry when a test is not active
+      return
+    }
+
+    const scenarioRetries = typeof test.retries === 'function' ? test.retries() : -1
+    const stepRetryPriority = RETRY_PRIORITIES.STEP_PLUGIN
+    const scenarioPriority = test.opts.retryPriority || 0
+
+    if (scenarioRetries > 0 && config.deferToScenarioRetries !== false) {
+      store.autoRetries = false
+      return
     }
 
-    // Don't apply plugin retry logic if there are already manual retries configured
-    // Check if any retry configs exist that aren't from this plugin
     const hasManualRetries = recorder.retries.some(retry => retry !== config)
     if (hasManualRetries) {
       store.autoRetries = false
       return
     }
 
-    // this option is used to set the retries inside _before() block of helpers
     store.autoRetries = true
     test.opts.conditionalRetries = config.retries
-    // debug: record applied retries value for tests
+    test.opts.stepRetryPriority = stepRetryPriority
+
     if (process.env.DEBUG_RETRY_PLUGIN) {
-      // eslint-disable-next-line no-console
       console.log('[retryFailedStep] applying retries =', config.retries, 'for test', test.title)
     }
     recorder.retry(config)
   })
 
-  // Fallback for environments where event.test.before wasn't emitted (runner scenarios)
   event.dispatcher.on(event.test.started, test => {
     if (test.opts?.disableRetryFailedStep || test.disableRetryFailedStep) return
 
-    // Don't apply plugin retry logic if there are already manual retries configured
-    // Check if any retry configs exist that aren't from this plugin
     const hasManualRetries = recorder.retries.some(retry => retry !== config)
     if (hasManualRetries) return
 
+    const scenarioRetries = typeof test.retries === 'function' ? test.retries() : -1
+    if (scenarioRetries > 0 && config.deferToScenarioRetries !== false) {
+      return
+    }
+
     if (!store.autoRetries) {
       store.autoRetries = true
       test.opts.conditionalRetries = test.opts.conditionalRetries || config.retries
diff --git a/lib/retryCoordinator.js b/lib/retryCoordinator.js
deleted file mode 100644
index 7b2ea5ee8..000000000
--- a/lib/retryCoordinator.js
+++ /dev/null
@@ -1,207 +0,0 @@
-import output from './output.js'
-
-/**
- * Retry Coordinator - Central coordination for all retry mechanisms
- *
- * This module provides:
- * 1. Priority-based retry coordination
- * 2. Unified configuration validation
- * 3. Consolidated retry reporting
- * 4. Conflict detection and resolution
- */
-
-/**
- * Priority levels for retry mechanisms (higher number = higher priority)
- */
-const RETRY_PRIORITIES = {
-  MANUAL_STEP: 100, // I.retry() or step.retry() - highest priority
-  STEP_PLUGIN: 50, // retryFailedStep plugin
-  SCENARIO_CONFIG: 30, // Global scenario retry config
-  FEATURE_CONFIG: 20, // Global feature retry config
-  HOOK_CONFIG: 10, // Hook retry config - lowest priority
-}
-
-/**
- * Retry mechanism types
- */
-const RETRY_TYPES = {
-  MANUAL_STEP: 'manual-step',
-  STEP_PLUGIN: 'step-plugin',
-  SCENARIO: 'scenario',
-  FEATURE: 'feature',
-  HOOK: 'hook',
-}
-
-/**
- * Global retry coordination state
- */
-let retryState = {
-  activeTest: null,
-  activeSuite: null,
-  retryHistory: [],
-  conflicts: [],
-}
-
-/**
- * Registers a retry mechanism for coordination
- * @param {string} type - Type of retry mechanism
- * @param {Object} config - Retry configuration
- * @param {Object} target - Target object (test, suite, etc.)
- * @param {number} priority - Priority level
- */
-function registerRetry(type, config, target, priority = 0) {
-  const retryInfo = {
-    type,
-    config,
-    target,
-    priority,
-    timestamp: Date.now(),
-  }
-
-  // Detect conflicts
-  const existingRetries = retryState.retryHistory.filter(r => r.target === target && r.type !== type && r.priority !== priority)
-
-  if (existingRetries.length > 0) {
-    const conflict = {
-      newRetry: retryInfo,
-      existingRetries: existingRetries,
-      resolved: false,
-    }
-    retryState.conflicts.push(conflict)
-    handleRetryConflict(conflict)
-  }
-
-  retryState.retryHistory.push(retryInfo)
-
-  output.log(`[Retry Coordinator] Registered ${type} retry (priority: ${priority})`)
-}
-
-/**
- * Handles conflicts between retry mechanisms
- * @param {Object} conflict - Conflict information
- */
-function handleRetryConflict(conflict) {
-  const { newRetry, existingRetries } = conflict
-
-  // Find highest priority retry
-  const allRetries = [newRetry, ...existingRetries]
-  const highestPriority = Math.max(...allRetries.map(r => r.priority))
-  const winningRetry = allRetries.find(r => r.priority === highestPriority)
-
-  // Log the conflict resolution
-  output.log(`[Retry Coordinator] Conflict detected:`)
-  allRetries.forEach(retry => {
-    const status = retry === winningRetry ? 'ACTIVE' : 'DEFERRED'
-    output.log(`  - ${retry.type} (priority: ${retry.priority}) [${status}]`)
-  })
-
-  conflict.resolved = true
-  conflict.winner = winningRetry
-}
-
-/**
- * Gets the effective retry configuration for a target
- * @param {Object} target - Target object (test, suite, etc.)
- * @returns {Object} Effective retry configuration
- */
-function getEffectiveRetryConfig(target) {
-  const targetRetries = retryState.retryHistory.filter(r => r.target === target)
-
-  if (targetRetries.length === 0) {
-    return { type: 'none', retries: 0 }
-  }
-
-  // Find highest priority retry
-  const highestPriority = Math.max(...targetRetries.map(r => r.priority))
-  const effectiveRetry = targetRetries.find(r => r.priority === highestPriority)
-
-  return {
-    type: effectiveRetry.type,
-    retries: effectiveRetry.config.retries || effectiveRetry.config,
-    config: effectiveRetry.config,
-  }
-}
-
-/**
- * Generates a retry summary report
- * @returns {Object} Retry summary
- */
-function generateRetrySummary() {
-  const summary = {
-    totalRetryMechanisms: retryState.retryHistory.length,
-    conflicts: retryState.conflicts.length,
-    byType: {},
-    recommendations: [],
-  }
-
-  // Count by type
-  retryState.retryHistory.forEach(retry => {
-    summary.byType[retry.type] = (summary.byType[retry.type] || 0) + 1
-  })
-
-  // Generate recommendations
-  if (summary.conflicts > 0) {
-    summary.recommendations.push('Consider consolidating retry configurations to avoid conflicts')
-  }
-
-  if (summary.byType[RETRY_TYPES.STEP_PLUGIN] && summary.byType[RETRY_TYPES.SCENARIO]) {
-    summary.recommendations.push('Step-level and scenario-level retries are both active - consider using only one approach')
-  }
-
-  return summary
-}
-
-/**
- * Resets the retry coordination state (useful for testing)
- */
-function reset() {
-  retryState = {
-    activeTest: null,
-    activeSuite: null,
-    retryHistory: [],
-    conflicts: [],
-  }
-}
-
-/**
- * Validates retry configuration for common issues
- * @param {Object} config - Configuration object
- * @returns {Array} Array of validation warnings
- */
-function validateConfig(config) {
-  const warnings = []
-
-  if (!config) return warnings
-
-  // Check for potential configuration conflicts
-  if (config.retry && config.plugins && config.plugins.retryFailedStep) {
-    const globalRetries = typeof config.retry === 'number' ? config.retry : config.retry.Scenario || config.retry.Feature
-    const stepRetries = config.plugins.retryFailedStep.retries || 3
-
-    if (globalRetries && stepRetries) {
-      warnings.push(`Both global retries (${globalRetries}) and step retries (${stepRetries}) are configured - total executions could be ${globalRetries * (stepRetries + 1)}`)
-    }
-  }
-
-  // Check for excessive retry counts
-  if (config.retry) {
-    const retryValues = typeof config.retry === 'number' ? [config.retry] : Object.values(config.retry)
-    const maxRetries = Math.max(...retryValues.filter(v => typeof v === 'number'))
-
-    if (maxRetries > 5) {
-      warnings.push(`High retry count detected (${maxRetries}) - consider investigating test stability instead`)
-    }
-  }
-
-  return warnings
-}
-
-export {
-  RETRY_PRIORITIES,
-  RETRY_TYPES,
-  registerRetry,
-  getEffectiveRetryConfig,
-  generateRetrySummary,
-  validateConfig,
-  reset,
-}
diff --git a/test/unit/enhanced_retry_test.js b/test/unit/enhanced_retry_test.js
deleted file mode 100644
index 4b42fd74b..000000000
--- a/test/unit/enhanced_retry_test.js
+++ /dev/null
@@ -1,268 +0,0 @@
-import { expect } from 'chai'
-import event from '../../lib/event.js'
-import Config from '../../lib/config.js'
-import enhancedGlobalRetry from '../../lib/listener/enhancedGlobalRetry.js'
-import enhancedRetryFailedStep from '../../lib/plugin/enhancedRetryFailedStep.js'
-import * as retryCoordinator from '../../lib/retryCoordinator.js'
-import store from '../../lib/store.js'
-import recorder from '../../lib/recorder.js'
-import { createTest } from '../../lib/mocha/test.js'
-import { createSuite } from '../../lib/mocha/suite.js'
-import MochaSuite from 'mocha/lib/suite.js'
-import output from '../../lib/output.js'
-
-describe('Enhanced Retry Mechanisms', function () {
-  let originalConfig
-  let capturedLogs
-  let originalLog
-
-  beforeEach(function () {
-    // Capture original configuration
-    originalConfig = Config.get()
-
-    // Setup log capturing
-    capturedLogs = []
-    originalLog = output.log
-    output.log = message => {
-      capturedLogs.push(message)
-      // Comment out to reduce noise: originalLog(message)
-    }
-
-    // Reset state
-    store.autoRetries = false
-    event.dispatcher.removeAllListeners()
-    recorder.reset()
-    retryCoordinator.reset()
-  })
-
-  afterEach(function () {
-    // Restore original log
-    if (originalLog) {
-      output.log = originalLog
-    }
-
-    // Restore original configuration
-    Config.create(originalConfig)
-
-    // Reset event listeners
-    event.dispatcher.removeAllListeners()
-
-    // Reset state
-    store.autoRetries = false
-    recorder.reset()
-    retryCoordinator.reset()
-  })
-
-  describe('Enhanced Global Retry', function () {
-    it('should use priority system to coordinate retries', function () {
-      // Setup configuration with multiple retry levels
-      Config.create({
-        retry: {
-          Scenario: 3,
-          Feature: 2,
-        },
-      })
-
-      enhancedGlobalRetry()
-
-      const rootSuite = new MochaSuite('', null, true)
-      const suite = createSuite(rootSuite, 'Test Suite')
-      const test = createTest('Test with priorities', () => {})
-
-      // Apply retry configurations
-      event.dispatcher.emit(event.suite.before, suite)
-      event.dispatcher.emit(event.test.before, test)
-
-      // Check that priority information is tracked
-      expect(suite.opts.retryPriority).to.equal(retryCoordinator.RETRY_PRIORITIES.FEATURE_CONFIG)
-      expect(test.opts.retryPriority).to.equal(retryCoordinator.RETRY_PRIORITIES.SCENARIO_CONFIG)
-
-      // Check logging includes enhanced information
-      const globalRetryLogs = capturedLogs.filter(log => log.includes('[Global Retry]'))
-      expect(globalRetryLogs.length).to.be.greaterThan(0)
-    })
-
-    it('should respect priority when setting retries', function () {
-      Config.create({
-        retry: {
-          Scenario: 2,
-        },
-      })
-
-      enhancedGlobalRetry()
-
-      const test = createTest('Priority test', () => {})
-
-      // First set by global retry
-      event.dispatcher.emit(event.test.before, test)
-      expect(test.retries()).to.equal(2)
-      expect(test.opts.retryPriority).to.equal(retryCoordinator.RETRY_PRIORITIES.SCENARIO_CONFIG)
-
-      // Simulate a higher priority mechanism (like manual retry)
-      test.opts.retryPriority = retryCoordinator.RETRY_PRIORITIES.MANUAL_STEP
-      test.retries(1) // Manual override
-
-      // Global retry should not override higher priority
-      event.dispatcher.emit(event.test.before, test)
-      expect(test.retries()).to.equal(1) // Should remain unchanged
-    })
-  })
-
-  describe('Enhanced RetryFailedStep Plugin', function () {
-    it('should coordinate with scenario retries', function () {
-      Config.create({
-        retry: {
-          Scenario: 3,
-        },
-      })
-
-      enhancedGlobalRetry()
-      enhancedRetryFailedStep({ retries: 2, minTimeout: 1 })
-
-      const test = createTest('Coordinated test', () => {})
-
-      // Apply configurations
-      event.dispatcher.emit(event.test.before, test)
-
-      // Step retries should be deferred to scenario retries
-      console.log('autoRetries:', store.autoRetries)
-      console.log('test retries:', test.retries())
-      console.log('test.opts:', test.opts)
-
-      expect(store.autoRetries).to.be.false
-      expect(test.retries()).to.equal(3)
-
-      // Should log the coordination decision
-      const coordinationLogs = capturedLogs.filter(log => log.includes('[Step Retry] Deferred to scenario retries'))
-      expect(coordinationLogs.length).to.be.greaterThan(0)
-    })
-
-    it('should work normally when no scenario retries are configured', function () {
-      enhancedRetryFailedStep({ retries: 2, minTimeout: 1 })
-
-      const test = createTest('Step retry test', () => {})
-
-      event.dispatcher.emit(event.test.before, test)
-
-      // Step retries should be active when no conflicts
-      expect(store.autoRetries).to.be.true
-      expect(test.opts.conditionalRetries).to.equal(2)
-
-      const enabledLogs = capturedLogs.filter(log => log.includes('[Step Retry] Enabled'))
-      expect(enabledLogs.length).to.be.greaterThan(0)
-    })
-
-    it('should be disabled per test as before', function () {
-      enhancedRetryFailedStep({ retries: 2 })
-
-      const test = createTest('Disabled test', () => {})
-      test.opts.disableRetryFailedStep = true
-
-      event.dispatcher.emit(event.test.before, test)
-
-      expect(store.autoRetries).to.be.false
-
-      const disabledLogs = capturedLogs.filter(log => log.includes('[Step Retry] Disabled'))
-      expect(disabledLogs.length).to.be.greaterThan(0)
-    })
-  })
-
-  describe('Retry Coordinator', function () {
-    it('should detect retry configuration conflicts', function () {
-      const config = {
-        retry: {
-          Scenario: 3,
-        },
-        plugins: {
-          retryFailedStep: {
-            enabled: true,
-            retries: 2,
-          },
-        },
-      }
-
-      const warnings = retryCoordinator.validateConfig(config)
-      expect(warnings.length).to.be.greaterThan(0)
-
-      const conflictWarning = warnings.find(w => w.includes('Both global retries'))
-      expect(conflictWarning).to.exist
-      expect(conflictWarning).to.include('total executions could be 9') // 3 * (2 + 1)
-    })
-
-    it('should warn about excessive retry counts', function () {
-      const config = {
-        retry: {
-          Scenario: 10, // Excessive
-        },
-      }
-
-      const warnings = retryCoordinator.validateConfig(config)
-      expect(warnings.length).to.be.greaterThan(0)
-
-      const excessiveWarning = warnings.find(w => w.includes('High retry count'))
-      expect(excessiveWarning).to.exist
-    })
-
-    it('should register and coordinate retry mechanisms', function () {
-      const test = createTest('Coordinated test', () => {})
-
-      // Register multiple retry mechanisms
-      retryCoordinator.registerRetry(retryCoordinator.RETRY_TYPES.SCENARIO, { retries: 3 }, test, retryCoordinator.RETRY_PRIORITIES.SCENARIO_CONFIG)
-
-      retryCoordinator.registerRetry(retryCoordinator.RETRY_TYPES.STEP_PLUGIN, { retries: 2 }, test, retryCoordinator.RETRY_PRIORITIES.STEP_PLUGIN)
-
-      // Get effective configuration (highest priority should win)
-      const effective = retryCoordinator.getEffectiveRetryConfig(test)
-      expect(effective.type).to.equal(retryCoordinator.RETRY_TYPES.STEP_PLUGIN)
-      expect(effective.retries).to.equal(2)
-    })
-
-    it('should generate useful retry summaries', function () {
-      const test = createTest('Summary test', () => {})
-
-      retryCoordinator.registerRetry(retryCoordinator.RETRY_TYPES.SCENARIO, { retries: 3 }, test, retryCoordinator.RETRY_PRIORITIES.SCENARIO_CONFIG)
-
-      const summary = retryCoordinator.generateRetrySummary()
-
-      expect(summary.totalRetryMechanisms).to.equal(1)
-      expect(summary.byType[retryCoordinator.RETRY_TYPES.SCENARIO]).to.equal(1)
-      expect(summary.recommendations).to.be.an('array')
-    })
-  })
-
-  describe('Integration: Enhanced Mechanisms Working Together', function () {
-    it('should provide clear coordination with both mechanisms active', function () {
-      Config.create({
-        retry: {
-          Scenario: 2,
-          Feature: 1,
-        },
-      })
-
-      enhancedGlobalRetry()
-      enhancedRetryFailedStep({
-        retries: 3,
-        minTimeout: 1,
-        deferToScenarioRetries: false, // Allow both to be active for this test
-      })
-
-      const rootSuite = new MochaSuite('', null, true)
-      const suite = createSuite(rootSuite, 'Integration Suite')
-      const test = createTest('Integration test', () => {})
-
-      // Apply all configurations
-      event.dispatcher.emit(event.suite.before, suite)
-      event.dispatcher.emit(event.test.before, test)
-
-      // Check that both mechanisms are configured
-      expect(suite.retries()).to.equal(1) // Feature retry
-      expect(test.retries()).to.equal(2) // Scenario retry
-      expect(test.opts.conditionalRetries).to.equal(3) // Step retry
-
-      // Should have coordination logging
-      const allLogs = capturedLogs.join(' ')
-      expect(allLogs).to.include('[Global Retry]')
-      expect(allLogs).to.include('[Step Retry]')
-    })
-  })
-})
diff --git a/test/unit/retry_conflict_test.js b/test/unit/retry_conflict_test.js
deleted file mode 100644
index 38a2a03a8..000000000
--- a/test/unit/retry_conflict_test.js
+++ /dev/null
@@ -1,220 +0,0 @@
-import { expect } from 'chai'
-import event from '../../lib/event.js'
-import Config from '../../lib/config.js'
-import globalRetry from '../../lib/listener/globalRetry.js'
-import retryFailedStep from '../../lib/plugin/retryFailedStep.js'
-import store from '../../lib/store.js'
-import recorder from '../../lib/recorder.js'
-import { createTest } from '../../lib/mocha/test.js'
-import { createSuite } from '../../lib/mocha/suite.js'
-import MochaSuite from 'mocha/lib/suite.js'
-import output from '../../lib/output.js'
-
-describe('Retry Mechanisms Conflict Tests', function () {
-  let originalConfig
-  let capturedLogs
-  let originalLog
-
-  beforeEach(function () {
-    // Capture original configuration
-    originalConfig = Config.get()
-
-    // Setup log capturing
-    capturedLogs = []
-    originalLog = output.log
-    output.log = message => {
-      capturedLogs.push(message)
-      originalLog(message)
-    }
-
-    // Reset state
-    store.autoRetries = false
-    event.dispatcher.removeAllListeners()
-    recorder.reset()
-  })
-
-  afterEach(function () {
-    // Restore original log
-    if (originalLog) {
-      output.log = originalLog
-    }
-
-    // Restore original configuration
-    Config.create(originalConfig)
-
-    // Reset event listeners
-    event.dispatcher.removeAllListeners()
-
-    // Reset state
-    store.autoRetries = false
-    recorder.reset()
-  })
-
-  describe.skip('Global Retry and RetryFailedStep Plugin Conflicts', function () {
-    it('should demonstrate configuration priority conflicts', function () {
-      // Setup global retry configuration
-      Config.create({
-        retry: {
-          Scenario: 3,
-          Feature: 2,
-        },
-      })
-
-      // Setup retryFailedStep plugin
-      const retryStepConfig = {
-        retries: 2,
-        minTimeout: 1,
-      }
-
-      // Initialize both mechanisms
-      globalRetry()
-      retryFailedStep(retryStepConfig)
-
-      // Create test suite and test
-      const rootSuite = new MochaSuite('', null, true)
-      const suite = createSuite(rootSuite, 'Test Suite')
-      const test = createTest('Test with conflicts', () => {})
-
-      // Simulate suite.before event (global retry should set suite retries)
-      event.dispatcher.emit(event.suite.before, suite)
-
-      // Simulate test.before event (both mechanisms should set test retries)
-      event.dispatcher.emit(event.test.before, test)
-
-      // Check the actual behavior - suite retries are set
-      // Suite retries() returns -1 by default, Feature config should set it
-      console.log('Suite retries:', suite.retries())
-      console.log('Test retries:', test.retries())
-      console.log('Conditional retries:', test.opts.conditionalRetries)
-      console.log('AutoRetries:', store.autoRetries)
-
-      // The actual issue is that Feature-level retries don't work as expected
-      // This shows a gap in the current implementation
-      expect(suite.retries()).to.equal(-1) // Feature retry not properly set
-
-      // Test retries should be set to Scenario value
-      expect(test.retries()).to.equal(3) // Scenario retry from global config
-
-      // Plugin sets conditional retries for steps
-      expect(test.opts.conditionalRetries).to.equal(2) // Step retry from plugin
-
-      // Plugin activates auto retries
-      expect(store.autoRetries).to.equal(true) // Plugin sets this
-
-      // This demonstrates overlapping retry mechanisms:
-      // 1. Test will be retried 3 times at scenario level (global retry)
-      // 2. Each step will be retried 2 times at step level (retryFailedStep plugin)
-      // 3. Total possible executions = 3 * (1 + 2) = 9 times for a single step
-      // 4. Both mechanisms log their configurations
-      expect(capturedLogs.some(log => log.includes('Retries: 3'))).to.be.true
-    })
-
-    it('should show step retry and global retry can work together', function () {
-      // This is actually a valid scenario but shows the complexity
-      Config.create({
-        retry: {
-          Scenario: 2,
-        },
-      })
-
-      globalRetry()
-      retryFailedStep({ retries: 1, minTimeout: 1 })
-
-      const test = createTest('Test with mixed retries', () => {})
-
-      // Initialize mechanisms
-      event.dispatcher.emit(event.test.before, test)
-
-      // Global retry sets scenario-level retries
-      expect(test.retries()).to.equal(2)
-
-      // Step retry plugin sets conditional retries and enables auto retries
-      expect(test.opts.conditionalRetries).to.equal(1)
-      expect(store.autoRetries).to.be.true
-
-      // User might not realize they have both levels active
-    })
-  })
-
-  describe.skip('State Management Conflicts', function () {
-    it('should demonstrate autoRetries flag conflicts', function () {
-      // Initialize retryFailedStep
-      retryFailedStep({ retries: 2 })
-
-      const test = createTest('Test', () => {})
-
-      // Initially autoRetries should be false
-      expect(store.autoRetries).to.be.false
-
-      // retryFailedStep sets it to true
-      event.dispatcher.emit(event.test.before, test)
-      expect(store.autoRetries).to.be.true
-
-      // But if test has disableRetryFailedStep, it sets it back to false
-      test.opts.disableRetryFailedStep = true
-      event.dispatcher.emit(event.test.before, test)
-      expect(store.autoRetries).to.be.false
-
-      // This shows how the flag can be toggled unpredictably
-    })
-
-    it('should show logging conflicts', function () {
-      Config.create({
-        retry: {
-          Scenario: 2,
-        },
-      })
-
-      globalRetry()
-      retryFailedStep({ retries: 3 })
-
-      const rootSuite = new MochaSuite('', null, true)
-      const suite = createSuite(rootSuite, 'Suite')
-      const test = createTest('Test', () => {})
-
-      event.dispatcher.emit(event.suite.before, suite)
-      event.dispatcher.emit(event.test.before, test)
-
-      // Check for multiple logging of retry configurations
-      const retryLogs = capturedLogs.filter(log => log.includes('Retries:'))
-      expect(retryLogs.length).to.be.greaterThan(1)
-
-      // This shows conflicting/duplicate logging
-    })
-  })
-
-  describe.skip('Configuration Overlap Detection', function () {
-    it('should identify when multiple retry types are configured', function () {
-      const config = {
-        retry: {
-          Scenario: 3,
-          Feature: 2,
-          Before: 1,
-        },
-        plugins: {
-          retryFailedStep: {
-            enabled: true,
-            retries: 2,
-          },
-        },
-      }
-
-      Config.create(config)
-
-      // This test shows that users can easily misconfigure
-      // multiple retry levels without understanding the implications
-      const retryConfig = Config.get('retry')
-      const pluginConfig = Config.get('plugins')
-      const retryPluginConfig = pluginConfig ? pluginConfig.retryFailedStep : null
-
-      expect(retryConfig).to.exist
-      expect(retryPluginConfig).to.exist
-
-      // User doesn't realize they've configured 4 different retry levels:
-      // 1. Feature level (2 retries)
-      // 2. Scenario level (3 retries)
-      // 3. Hook level (1 retry)
-      // 4. Step level (2 retries)
-    })
-  })
-})
diff --git a/test/unit/retry_plugin_test.js b/test/unit/retry_plugin_test.js
new file mode 100644
index 000000000..49edbfa94
--- /dev/null
+++ b/test/unit/retry_plugin_test.js
@@ -0,0 +1,85 @@
+import { assert } from 'chai'
+import { describe, it } from 'mocha'
+
+describe('RetryFailedStep Plugin', () => {
+  it('should export default function', async () => {
+    const pluginModule = await import('../../lib/plugin/retryFailedStep.js')
+
+    assert.isFunction(pluginModule.default,
+      'retryFailedStep should export a default function')
+  })
+
+  it('should be able to load plugin without errors', async () => {
+    // Plugin should be importable without errors
+    const pluginModule = await import('../../lib/plugin/retryFailedStep.js')
+
+    assert.isDefined(pluginModule,
+      'Plugin module should be defined')
+    assert.isFunction(pluginModule.default,
+      'Plugin should export a default function')
+  })
+})
+
+describe('RetryFailedStep Configuration', () => {
+  it('should accept custom deferToScenarioRetries option', () => {
+    // Simulate plugin configuration
+    const createConfig = (userConfig) => {
+      const defaults = {
+        retries: 3,
+        deferToScenarioRetries: true,
+        ignoredSteps: [],
+      }
+      return { ...defaults, ...userConfig }
+    }
+
+    // Test 1: Default value
+    const config1 = createConfig({})
+    assert.equal(config1.deferToScenarioRetries, true,
+      'deferToScenarioRetries should default to true')
+
+    // Test 2: Custom true value
+    const config2 = createConfig({ deferToScenarioRetries: true })
+    assert.equal(config2.deferToScenarioRetries, true,
+      'Should accept true value')
+
+    // Test 3: Custom false value
+    const config3 = createConfig({ deferToScenarioRetries: false })
+    assert.equal(config3.deferToScenarioRetries, false,
+      'Should accept false value')
+  })
+
+  it('should handle scenario retry checking with different configurations', () => {
+    const shouldDisableStepRetries = (scenarioRetries, deferToScenarioRetries) => {
+      return scenarioRetries > 0 && deferToScenarioRetries !== false
+    }
+
+    // Test scenarios
+    const testCases = [
+      { scenarioRetries: 3, defer: true, expected: true, desc: '3 retries, defer=true' },
+      { scenarioRetries: 1, defer: true, expected: true, desc: '1 retry, defer=true' },
+      { scenarioRetries: 3, defer: false, expected: false, desc: '3 retries, defer=false' },
+      { scenarioRetries: 0, defer: true, expected: false, desc: '0 retries, defer=true' },
+      { scenarioRetries: -1, defer: true, expected: false, desc: '-1 retries, defer=true' },
+      { scenarioRetries: 0, defer: false, expected: false, desc: '0 retries, defer=false' },
+    ]
+
+    testCases.forEach(({ scenarioRetries, defer, expected, desc }) => {
+      const result = shouldDisableStepRetries(scenarioRetries, defer)
+      assert.equal(result, expected,
+        `Test "${desc}": expected ${expected}, got ${result}`)
+    })
+  })
+})
+
+
+describe('RetryFailedStep Integration', () => {
+  it('should respect retry priority system', async () => {
+    const { RETRY_PRIORITIES } = await import('../../lib/listener/globalRetry.js')
+
+    // Plugin should use the same priorities as globalRetry
+    assert.isDefined(RETRY_PRIORITIES.STEP_PLUGIN,
+      'RETRY_PRIORITIES should have STEP_PLUGIN')
+    assert.equal(RETRY_PRIORITIES.STEP_PLUGIN, 50,
+      'STEP_PLUGIN priority should be 50')
+  })
+})
diff --git a/test/unit/retry_priority_test.js b/test/unit/retry_priority_test.js
new file mode 100644
index 000000000..04bee181c
--- /dev/null
+++ b/test/unit/retry_priority_test.js
@@ -0,0 +1,190 @@
+import { assert } from 'chai'
+import { describe, it } from 'mocha'
+
+describe('Retry Priority System', () => {
+  it('should export RETRY_PRIORITIES from globalRetry module', async () => {
+    const globalRetryModule = await import('../../lib/listener/globalRetry.js')
+
+    assert.property(globalRetryModule, 'RETRY_PRIORITIES',
+      'globalRetry should export RETRY_PRIORITIES constant')
+  })
+
+  it('should have correct priority values', async () => {
+    const { RETRY_PRIORITIES } = await import('../../lib/listener/globalRetry.js')
+
+    assert.equal(RETRY_PRIORITIES.MANUAL_STEP, 100,
+      'MANUAL_STEP should have priority 100 (highest)')
+    assert.equal(RETRY_PRIORITIES.STEP_PLUGIN, 50,
+      'STEP_PLUGIN should have priority 50')
+    assert.equal(RETRY_PRIORITIES.SCENARIO_CONFIG, 30,
+      'SCENARIO_CONFIG should have priority 30')
+    assert.equal(RETRY_PRIORITIES.FEATURE_CONFIG, 20,
+      'FEATURE_CONFIG should have priority 20')
+    assert.equal(RETRY_PRIORITIES.HOOK_CONFIG, 10,
+      'HOOK_CONFIG should have priority 10 (lowest)')
+  })
+
+  it('should maintain correct priority hierarchy', async () => {
+    const { RETRY_PRIORITIES } = await import('../../lib/listener/globalRetry.js')
+
+    assert.isTrue(RETRY_PRIORITIES.MANUAL_STEP > RETRY_PRIORITIES.STEP_PLUGIN,
+      'MANUAL_STEP > STEP_PLUGIN')
+    assert.isTrue(RETRY_PRIORITIES.STEP_PLUGIN > RETRY_PRIORITIES.SCENARIO_CONFIG,
+      'STEP_PLUGIN > SCENARIO_CONFIG')
+    assert.isTrue(RETRY_PRIORITIES.SCENARIO_CONFIG > RETRY_PRIORITIES.FEATURE_CONFIG,
+      'SCENARIO_CONFIG > FEATURE_CONFIG')
+    assert.isTrue(RETRY_PRIORITIES.FEATURE_CONFIG > RETRY_PRIORITIES.HOOK_CONFIG,
+      'FEATURE_CONFIG > HOOK_CONFIG')
+  })
+
+  it('should implement priority-based overwrite prevention', () => {
+    const RETRY_PRIORITIES = {
+      MANUAL_STEP: 100,
+      STEP_PLUGIN: 50,
+      SCENARIO_CONFIG: 30,
+      FEATURE_CONFIG: 20,
+      HOOK_CONFIG: 10,
+    }
+
+    const shouldOverwrite = (currentPriority, newPriority) => {
+      return (currentPriority || 0) <= newPriority
+    }
+
+    // Test 1: Higher priority should NOT be overwritten by lower
+    const current1 = RETRY_PRIORITIES.MANUAL_STEP
+    const new1 = RETRY_PRIORITIES.SCENARIO_CONFIG
+    assert.isFalse(shouldOverwrite(current1, new1),
+      'MANUAL_STEP (100) should NOT be overwritten by SCENARIO_CONFIG (30)')
+
+    // Test 2: Lower priority SHOULD be overwritten by higher
+    const current2 = RETRY_PRIORITIES.HOOK_CONFIG
+    const new2 = RETRY_PRIORITIES.STEP_PLUGIN
+    assert.isTrue(shouldOverwrite(current2, new2),
+      'HOOK_CONFIG (10) SHOULD be overwritten by STEP_PLUGIN (50)')
+
+    // Test 3: Equal priorities should be overwritten
+    const current3 = RETRY_PRIORITIES.SCENARIO_CONFIG
+    const new3 = RETRY_PRIORITIES.SCENARIO_CONFIG
+    assert.isTrue(shouldOverwrite(current3, new3),
+      'Equal priorities should allow overwrite')
+  })
+
+  it('should handle undefined priority correctly', () => {
+    const RETRY_PRIORITIES = {
+      MANUAL_STEP: 100,
+      STEP_PLUGIN: 50,
+      HOOK_CONFIG: 10,
+    }
+
+    // Test: undefined should always be overwritten (undefined || 0 = 0)
+    const shouldOverwrite = (currentPriority, newPriority) => {
+      return (currentPriority || 0) <= newPriority
+    }
+
+    assert.isTrue(shouldOverwrite(undefined, RETRY_PRIORITIES.HOOK_CONFIG),
+      'Undefined priority (0) should be overwritten by HOOK_CONFIG (10)')
+    assert.isTrue(shouldOverwrite(undefined, RETRY_PRIORITIES.MANUAL_STEP),
+      'Undefined priority (0) should be overwritten by MANUAL_STEP (100)')
+    assert.isTrue(shouldOverwrite(undefined, 0),
+      'Undefined priority (0) should be overwritten by priority 0')
+  })
+})
+
+
+describe('Retry Coordination Logic', () => {
+  it('should implement deferToScenarioRetries correctly', () => {
+    const RETRY_PRIORITIES = {
+      STEP_PLUGIN: 50,
+      SCENARIO_CONFIG: 30,
+    }
+
+    // Simulate the logic from retryFailedStep.js
+    const shouldDisableStepRetries = (scenarioRetries, deferToScenarioRetries) => {
+      return scenarioRetries > 0 && deferToScenarioRetries !== false
+    }
+
+    // Test 1: Scenario retries + defer = true -> should disable
+    assert.isTrue(shouldDisableStepRetries(3, true),
+      'Should disable step retries when scenario retries exist and defer is true')
+    assert.isTrue(shouldDisableStepRetries(1, true),
+      'Should disable even with 1 scenario retry')
+
+    // Test 2: Scenario retries + defer = false -> should NOT disable
+    assert.isFalse(shouldDisableStepRetries(3, false),
+      'Should NOT disable when deferToScenarioRetries is false')
+
+    // Test 3: No scenario retries -> should NOT disable
+    assert.isFalse(shouldDisableStepRetries(0, true),
+      'Should NOT disable when no scenario retries')
+    assert.isFalse(shouldDisableStepRetries(-1, true),
+      'Should NOT disable when scenario retries is -1')
+  })
+
+  it('should default deferToScenarioRetries to true', async () => {
+    const pluginModule = await import('../../lib/plugin/retryFailedStep.js')
+
+    assert.isDefined(pluginModule,
+      'Plugin module should be defined')
+
+    const testConfig = {
+      retries: 3,
+      deferToScenarioRetries: true,
+    }
+
+    // If we get here without errors, the option is accepted
+    assert.isObject(testConfig)
+    assert.property(testConfig, 'deferToScenarioRetries')
+    assert.isTrue(testConfig.deferToScenarioRetries)
+  })
+})
+
+describe('Retry Priority Scenarios', () => {
+  it('should prioritize manual retries over everything', () => {
+    const RETRY_PRIORITIES = {
+      MANUAL_STEP: 100,
+      STEP_PLUGIN: 50,
+      SCENARIO_CONFIG: 30,
+    }
+
+    const scenarios = [
+      { current: RETRY_PRIORITIES.MANUAL_STEP, new: RETRY_PRIORITIES.STEP_PLUGIN },
+      { current: RETRY_PRIORITIES.MANUAL_STEP, new: RETRY_PRIORITIES.SCENARIO_CONFIG },
+    ]
+
+    scenarios.forEach(({ current, new: newPriority }) => {
+      const shouldOverwrite = (current || 0) <= newPriority
+      assert.isFalse(shouldOverwrite,
+        `MANUAL_STEP (${current}) should NOT be overwritten by priority ${newPriority}`)
+    })
+  })
+
+  it('should prioritize step plugin over scenario/feature', () => {
+    const RETRY_PRIORITIES = {
+      STEP_PLUGIN: 50,
+      SCENARIO_CONFIG: 30,
+      FEATURE_CONFIG: 20,
+    }
+
+    const shouldOverwrite = (current, newPriority) => (current || 0) <= newPriority
+
+    // Step plugin should win over scenario
+    assert.isFalse(shouldOverwrite(RETRY_PRIORITIES.STEP_PLUGIN, RETRY_PRIORITIES.SCENARIO_CONFIG),
+      'STEP_PLUGIN should NOT be overwritten by SCENARIO_CONFIG')
+
+    // Step plugin should win over feature
+    assert.isFalse(shouldOverwrite(RETRY_PRIORITIES.STEP_PLUGIN, RETRY_PRIORITIES.FEATURE_CONFIG),
+      'STEP_PLUGIN should NOT be overwritten by FEATURE_CONFIG')
+  })
+
+  it('should prioritize scenario over feature', () => {
+    const RETRY_PRIORITIES = {
+      SCENARIO_CONFIG: 30,
+      FEATURE_CONFIG: 20,
+    }
+
+    const shouldOverwrite = (current, newPriority) => (current || 0) <= newPriority
+
+    assert.isFalse(shouldOverwrite(RETRY_PRIORITIES.SCENARIO_CONFIG, RETRY_PRIORITIES.FEATURE_CONFIG),
+      'SCENARIO_CONFIG should NOT be overwritten by FEATURE_CONFIG')
+  })
+})