dd-trace 6.7.0 → 6.9.0

package/packages/datadog-instrumentations/src/jest.js

@@ -1,16 +1,23 @@
 'use strict'
 
 // Capture real timers at module load time, before any test can install fake timers.
+const realClearTimeout = clearTimeout
 const realSetTimeout = setTimeout
 
 const { readFileSync } = require('node:fs')
 const { builtinModules, createRequire } = require('node:module')
+const { performance } = require('node:perf_hooks')
 const path = require('path')
 const satisfies = require('../../../vendor/dist/semifies')
 const { DD_MAJOR } = require('../../../version')
 const shimmer = require('../../datadog-shimmer')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const log = require('../../dd-trace/src/log')
+const {
+  EMPTY_EFD_RETRY_POLICY,
+  getEfdRetryCountForDuration,
+  hasEfdRetries,
+} = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
 const {
   getCoveredFilesFromCoverage,
   getExecutableFilesFromCoverage,
@@ -27,10 +34,11 @@ const {
   isModifiedTest,
   DYNAMIC_NAME_RE,
   collectDynamicNamesFromTraces,
+  recordTestManagementExecution,
   recordAttemptToFixExecution,
   logAttemptToFixTestExecution,
   logTestOptimizationSummary,
-  getEfdRetryCount,
+  TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE,
   getTestCoverageLinesPercentage,
   applySkippedCoverageToCoverage,
   getTestOptimizationRequestResults,
@@ -96,7 +104,7 @@ const DD_JEST_HANDLE_TEST_EVENT_WRAPPED = Symbol('dd-trace:jest:handle-test-even
 const DD_JEST_HANDLE_TEST_EVENT_DATADOG = Symbol('dd-trace:jest:handle-test-event-datadog')
 const DD_JEST_CONCURRENT_TEST_ORIGINAL = Symbol('dd-trace:jest:concurrent-test-original')
 const isJestWorker = !!getEnvironmentVariable('JEST_WORKER_ID')
-const jestSessionState = globalThis[JEST_SESSION_STATE] || (globalThis[JEST_SESSION_STATE] = {})
+const jestSessionState = (globalThis[JEST_SESSION_STATE] ||= {})
 
 // https://github.com/jestjs/jest/blob/41f842a46bb2691f828c3a5f27fc1d6290495b82/packages/jest-circus/src/types.ts#L9C8-L9C54
 const RETRY_TIMES = Symbol.for('RETRY_TIMES')
@@ -115,8 +123,6 @@ let numSkippedSuites = 0
 let hasUnskippableSuites = false
 let hasForcedToRunSuites = false
 let isEarlyFlakeDetectionEnabled = false
-let earlyFlakeDetectionNumRetries = 0
-let earlyFlakeDetectionSlowTestRetries = {}
 let earlyFlakeDetectionFaultyThreshold = 30
 let isEarlyFlakeDetectionFaulty = false
 let hasFilteredSkippableSuites = false
@@ -141,8 +147,10 @@ const originalTestFns = new WeakMap()
 const originalHookFns = new WeakMap()
 const concurrentHookContextQueues = new WeakMap()
 const concurrentHookFns = new WeakMap()
+const efdRetryMetadataByTest = new WeakMap()
+const removedRetryTests = new WeakSet()
 const retriedTestsToNumAttempts = new Map()
-const newTestsTestStatuses = new Map()
+const efdTestStatuses = new Map()
 const attemptToFixRetriedTestsStatuses = new Map()
 const wrappedWorkerChannels = new WeakMap()
 // New tests whose names contain likely dynamic data (timestamps, UUIDs, etc.)
@@ -153,10 +161,12 @@ const testSuiteMockedFiles = new Map()
 const testsToBeRetried = new Set()
 // Per-test: how many EFD retries were determined after the first execution.
 const efdDeterminedRetries = new Map()
+// Per-test: total executions to report, including retries Jest ran before the test they belong to.
+const efdExpectedExecutions = new Map()
 // Tests whose first run exceeded the 5-min threshold — tagged "slow".
 const efdSlowAbortedTests = new Set()
-// Tests added as EFD new-test candidates (not ATF, not impacted).
-const efdNewTestCandidates = new Set()
+// Tests whose first execution determines the duration-based EFD retry count.
+const efdCandidates = new Set()
 // Tests that are genuinely new (not in known tests list).
 const newTests = new Set()
 const testSuiteJestObjects = new Map()
@@ -173,13 +183,39 @@ const handledJestEvents = new WeakSet()
  * @typedef {object} ConcurrentTestOptions
  * @property {(...args: unknown[]) => unknown} [concurrentTest]
  * @property {unknown} [concurrentTestThisArg]
+ * @property {EfdRetryGate[]} [efdRetryGates]
  * @property {boolean} [isAttemptToFixRetry]
  * @property {boolean} [isEfdRetry]
+ * @property {number} [efdRetryIndex]
  * @property {boolean} [isModified]
- * @property {(...args: unknown[]) => unknown} [serialTest]
- * @property {unknown} [serialTestThisArg]
  * @property {(...args: unknown[]) => unknown} [sourceTestFn]
  * @property {string} [testParameters]
+ * @property {number} [timeout]
+ */
+
+/**
+ * @typedef {object} JestRetryOptions
+ * @property {object} [concurrentTestState]
+ * @property {EfdRetryGate[]} [efdRetryGates]
+ * @property {object} jestEvent
+ * @property {object} state
+ * @property {boolean} [isModified]
+ * @property {number} retryCount
+ * @property {string} retryType
+ * @property {string} testFullName
+ */
+
+/**
+ * @typedef {object} EfdRetryGate
+ * @property {Promise<boolean>} promise
+ * @property {(shouldRun: boolean) => void} resolve
+ */
+
+/**
+ * @typedef {object} DetachedEfdRetry
+ * @property {object} ctx
+ * @property {() => void} resolve
+ * @property {() => void} start
  */
 
 const ATR_RETRY_SUPPRESSION_FLAG = '_ddDisableAtrRetry'
@@ -278,6 +314,10 @@ function getTestEnvironmentOptions (config) {
 
 const MAX_IGNORED_TEST_NAMES = 10
 
+/**
+ * @typedef {Parameters<typeof logTestOptimizationSummary>[0]} TestOptimizationSummary
+ */
+
 function getTestStats (testStatuses) {
   return testStatuses.reduce((acc, testStatus) => {
     acc[testStatus]++
@@ -288,22 +328,20 @@ function getTestStats (testStatuses) {
 /**
  * Formats the ignored-failure section for the Test Optimization summary.
  *
- * @param {{ efdNames: string[], quarantineNames: string[], totalCount: number } | undefined} ignoredFailures
+ * @param {{
+ *   efdNames: string[],
+ *   quarantineNames: string[],
+ *   totalCount: number,
+ *   efdFailureCount: number
+ * } | undefined} ignoredFailures
  * @returns {string}
  */
 function formatIgnoredFailuresSummary (ignoredFailures) {
-  if (!ignoredFailures) return ''
-
-  const items = []
+  if (!ignoredFailures?.efdFailureCount) return ''
 
-  for (const n of ignoredFailures.efdNames) {
-    items.push({ text: n, suffix: 'Early Flake Detection' })
-  }
-  for (const n of ignoredFailures.quarantineNames) {
-    items.push({ text: n, suffix: 'Quarantine' })
-  }
+  const items = ignoredFailures.efdNames.map(text => ({ text, suffix: 'Early Flake Detection' }))
 
-  if (items.length === 0 || ignoredFailures.totalCount <= 0) return ''
+  if (items.length === 0) return ''
 
   const shown = items.slice(0, MAX_IGNORED_TEST_NAMES)
   const more = items.length - shown.length
@@ -312,18 +350,28 @@ function formatIgnoredFailuresSummary (ignoredFailures) {
     .map(({ text, suffix }) => `  • ${text}${suffix ? ` (${suffix})` : ''}`)
     .join('\n') + moreSuffix
 
-  return `${ignoredFailures.totalCount} test failure(s) were ignored. Exit code set to 0.\n\n${formattedItems}`
+  return `${ignoredFailures.efdFailureCount} test failure(s) were ignored. Exit code set to 0.\n\n${formattedItems}`
 }
 
 /**
  * Logs a single "Datadog Test Optimization" summary at session end.
  *
- * @param {{ efdNames: string[], quarantineNames: string[], totalCount: number } | undefined} ignoredFailures
+ * @param {{
+ *   efdNames: string[],
+ *   quarantineNames: string[],
+ *   totalCount: number,
+ *   efdFailureCount: number
+ * } | undefined} ignoredFailures
+ * @param {NonNullable<TestOptimizationSummary['attemptToFixExecutions']>} attemptToFixExecutions
+ * @param {boolean} allTestsSkipped
  */
-function logSessionSummary (ignoredFailures, attemptToFixExecutions) {
+function logSessionSummary (ignoredFailures, attemptToFixExecutions, allTestsSkipped) {
   logTestOptimizationSummary({
     attemptToFixExecutions,
-    extraSections: [formatIgnoredFailuresSummary(ignoredFailures)],
+    extraSections: [
+      formatIgnoredFailuresSummary(ignoredFailures),
+      allTestsSkipped ? TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE : '',
+    ],
     newTestsWithDynamicNames,
   })
   loggedAttemptToFixTests.clear()
@@ -349,11 +397,11 @@ function getAttemptToFixExecutionsFromJestResults (result) {
 
     for (const { fullName, status } of testResults) {
       const testName = removeSeedSuffixFromTestName(fullName)
-      const testStatus = getTestStatusFromJestResult(status)
-      if (!testStatus) continue
-
       const testManagementTest = testManagementTestsForSuite[testName]?.properties
       if (!testManagementTest?.attempt_to_fix) continue
+      const testStatus = getTestStatusFromJestResult(status) ||
+        (status === 'pending' || status === 'todo' ? 'skip' : undefined)
+      if (!testStatus) continue
 
       recordAttemptToFixExecution(executions, {
         testSuite,
@@ -368,6 +416,51 @@ function getAttemptToFixExecutionsFromJestResults (result) {
   return executions
 }
 
+/**
+ * Records test-management results reported by Jest after all retries have finished.
+ *
+ * @param {{
+ *   globalConfig?: { rootDir?: string },
+ *   results: {
+ *     testResults: Array<{
+ *       testResults: Array<{ fullName: string, status: string }>,
+ *       testFilePath: string
+ *     }>
+ *   }
+ * }} result
+ * @param {string[]} quarantineFailureNames
+ */
+function recordTestManagementExecutionsFromJestResults (result, quarantineFailureNames) {
+  const rootDir = result.globalConfig?.rootDir || process.cwd()
+  const failedQuarantinedTests = new Set(quarantineFailureNames)
+
+  for (const { testResults, testFilePath } of result.results.testResults) {
+    const testSuite = getTestSuitePath(testFilePath, rootDir)
+    const testManagementTestsForSuite = testManagementTests
+      ?.jest
+      ?.suites
+      ?.[testSuite]
+      ?.tests
+    if (!testManagementTestsForSuite) continue
+
+    for (const { fullName, status } of testResults) {
+      const testName = removeSeedSuffixFromTestName(fullName)
+      const testManagementTest = testManagementTestsForSuite[testName]?.properties
+      if (!testManagementTest) continue
+
+      const name = `${testSuite} › ${testName}`
+      recordTestManagementExecution({
+        testSuite,
+        testName,
+        status: failedQuarantinedTests.has(name) ? 'fail' : getTestStatusFromJestResult(status),
+        isAttemptToFix: testManagementTest.attempt_to_fix,
+        isDisabled: testManagementTest.disabled,
+        isQuarantined: testManagementTest.quarantined,
+      })
+    }
+  }
+}
+
 function wrapConsoleErrorForJestReferenceErrors () {
   if (isConsoleErrorWrapped) return
 
@@ -465,8 +558,52 @@ function getWrappedCustomHandleTestEvent (handleTestEvent, datadogHandleTestEven
   return wrappedHandleTestEvent
 }
 
+/**
+ * Mirrors the test selection checks Jest Circus performs after publishing `test_start`.
+ *
+ * @param {object} test
+ * @param {boolean} hasFocusedTests
+ * @param {RegExp|undefined} testNamePattern
+ * @returns {boolean}
+ */
+function isJestTestSkipped (test, hasFocusedTests, testNamePattern) {
+  if (
+    test.mode === 'skip' ||
+    (hasFocusedTests && test.mode !== 'only') ||
+    (testNamePattern && !testNamePattern.test(getRawJestTestName(test)))
+  ) {
+    return true
+  }
+
+  let parent = test.parent
+  while (parent) {
+    if (parent.mode === 'skip') return true
+    parent = parent.parent
+  }
+  return false
+}
+
 function getWrappedEnvironment (BaseEnvironment, jestVersion) {
+  const hasConcurrentTestsStartEvent = satisfies(jestVersion, '>=30.0.0')
+  const hasTestsInChildren = satisfies(jestVersion, '>=26.0.0')
+
+  /**
+   * @param {object} describeBlock
+   * @returns {object[]|undefined}
+   */
+  function getTestEntries (describeBlock) {
+    return hasTestsInChildren ? describeBlock?.children : describeBlock?.tests
+  }
+
   return class DatadogEnvironment extends BaseEnvironment {
+    #activeDetachedEfdRetries
+    #detachedEfdRetryConcurrency
+    #detachedEfdRetryQueue
+    #discardedEfdRetryTests
+    #earlyFlakeDetectionRetryPolicy
+    #efdRetryGatesByName
+    #pendingPre30ConcurrentTests
+
     constructor (config, context) {
       super(config, context)
       const rootDir = config.globalConfig ? config.globalConfig.rootDir : config.rootDir
@@ -504,11 +641,16 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.concurrentTestContexts = new Map()
       this.concurrentTestStates = new WeakMap()
       this.concurrentTestSourceFns = new WeakMap()
+      this.testParametersByFunction = new WeakMap()
       this.wrappedConcurrentTestFunctions = new WeakSet()
       this.jestEachBind = undefined
+      this.#activeDetachedEfdRetries = 0
+      this.#detachedEfdRetryConcurrency = 1
+      this.#pendingPre30ConcurrentTests = 0
+      this.#earlyFlakeDetectionRetryPolicy =
+        this.testEnvironmentOptions._ddEarlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
 
       if (this.isKnownTestsEnabled) {
-        earlyFlakeDetectionSlowTestRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionSlowTestRetries ?? {}
         try {
           this.knownTestsForThisSuite = this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
 
@@ -579,6 +721,53 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
+    /**
+     * Rebuilds serial `test.each` so every generated row function keeps its parameters.
+     *
+     * @param {Function|undefined} test
+     * @returns {void}
+     */
+    bindTestEach (test) {
+      if (typeof test?.each !== 'function') return
+
+      const bind = this.getJestEachBind()
+      if (typeof bind !== 'function') {
+        const environment = this
+        shimmer.wrap(test, 'each', each => function (...args) {
+          const testParameters = getFormattedJestTestParameters(args)
+          const eachBind = each.apply(this, args)
+          return function (...args) {
+            const [testName] = args
+            environment.setNameToParams(testName, testParameters)
+            return eachBind.apply(this, args)
+          }
+        })
+        return
+      }
+
+      // Jest creates each row function at runtime, so Orchestrion cannot associate parameters statically.
+      const environment = this
+      test.each = function wrappedTestEach (...eachArgs) {
+        const testParameters = getFormattedJestTestParameters(eachArgs)
+        return function (...testArgs) {
+          let parameterIndex = 0
+          const eachTest = function (testName, testFn, ...callArgs) {
+            const parameters = testParameters?.[parameterIndex++]
+            if (parameters !== undefined && typeof testFn === 'function') {
+              environment.appendNameToParams(testName, parameters)
+              environment.testParametersByFunction.set(
+                testFn,
+                getTestParametersString(environment.nameToParams, testName)
+              )
+            }
+            return test.call(this, testName, testFn, ...callArgs)
+          }
+          const eachBind = bind(eachTest).apply(this, eachArgs)
+          return eachBind.apply(this, testArgs)
+        }
+      }
+    }
+
     /**
      * Wraps Jest's concurrent test registration methods so eager concurrent bodies
      * in older Jest versions execute inside their test span context.
@@ -604,10 +793,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       const concurrentTest = test?.concurrent
       if (typeof concurrentTest !== 'function') return
 
-      this.wrapConcurrentTestFunction(test, 'concurrent', state, test, test)
-      this.wrapConcurrentTestFunction(test.concurrent, 'only', state, test.only, test)
-      this.wrapConcurrentTestFunction(test.concurrent, 'failing', state, test.failing, test)
-      this.wrapConcurrentTestFunction(test.concurrent.only, 'failing', state, test.only?.failing, test.only)
+      this.wrapConcurrentTestFunction(test, 'concurrent', state)
+      this.wrapConcurrentTestFunction(test.concurrent, 'only', state)
+      this.wrapConcurrentTestFunction(test.concurrent, 'failing', state)
+      this.wrapConcurrentTestFunction(test.concurrent.only, 'failing', state)
     }
 
     /**
@@ -616,11 +805,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      * @param {object} target
      * @param {string} methodName
      * @param {object} state
-     * @param {Function|undefined} serialTest
-     * @param {unknown} serialTestThisArg
      * @returns {void}
      */
-    wrapConcurrentTestFunction (target, methodName, state, serialTest, serialTestThisArg) {
+    wrapConcurrentTestFunction (target, methodName, state) {
       let concurrentTest = target?.[methodName]
       if (typeof concurrentTest !== 'function') return
       if (this.wrappedConcurrentTestFunctions.has(concurrentTest)) return
@@ -646,9 +833,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           const wrappedTestFn = environment.createConcurrentTestFn(testName, testFn, asyncError, state, {
             concurrentTest,
             concurrentTestThisArg: this,
-            serialTest,
-            serialTestThisArg,
             sourceTestFn: environment.concurrentTestSourceFns.get(testFn),
+            timeout: args[0],
           })
           return concurrentTest.call(this, testName, wrappedTestFn, ...args)
         }
@@ -711,8 +897,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         concurrentTestThisArg: options?.concurrentTestThisArg,
         ctx: this.createConcurrentTestContext(testName, testFn, asyncError, state, options),
         numExecutions: 0,
-        serialTest: options?.serialTest,
-        serialTestThisArg: options?.serialTestThisArg,
         state,
         testFn,
       }
@@ -777,6 +961,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         frameworkVersion: jestVersion,
         isNew: isNewTest,
         isEfdRetry: options?.isEfdRetry === true,
+        efdRetryGates: options?.efdRetryGates,
+        efdRetryIndex: options?.efdRetryIndex,
         isAttemptToFix,
         isAttemptToFixRetry: options?.isAttemptToFixRetry === true,
         isJestRetry: false,
@@ -785,6 +971,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         isModified: options?.isModified ?? this.isTestModified(asyncError, sourceTestFn),
         hasDynamicName: isNewTest && DYNAMIC_NAME_RE.test(testFullName),
         testSuiteAbsolutePath: this.testSuiteAbsolutePath,
+        testTimeout: options?.timeout || state.testTimeout,
       }
       let contexts = this.concurrentTestContexts.get(testFullName)
       if (contexts) {
@@ -880,6 +1067,183 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
+    /**
+     * @param {object} concurrentTestState
+     * @param {number|undefined} startedAt
+     * @returns {void}
+     */
+    completePre30ConcurrentTest (concurrentTestState, startedAt) {
+      if (!concurrentTestState.trackEfdCompletion) return
+
+      concurrentTestState.trackEfdCompletion = false
+      const { ctx } = concurrentTestState
+      if (startedAt !== undefined) {
+        ctx.efdDurationMs = performance.now() - startedAt
+        this.determineEfdRetries(ctx.name, ctx.efdDurationMs)
+      }
+      this.#pendingPre30ConcurrentTests--
+      this.drainDetachedEfdRetries()
+    }
+
+    /**
+     * @param {object} concurrentTestState
+     * @param {unknown} result
+     * @param {number|undefined} startedAt
+     * @returns {unknown}
+     */
+    trackPre30ConcurrentTest (concurrentTestState, result, startedAt) {
+      if (typeof result?.then !== 'function') {
+        this.completePre30ConcurrentTest(concurrentTestState, startedAt)
+        return result
+      }
+
+      return Promise.resolve(result).finally(() => {
+        this.completePre30ConcurrentTest(concurrentTestState, startedAt)
+      })
+    }
+
+    /**
+     * @param {EfdRetryGate} retryGate
+     * @param {object} ctx
+     * @param {() => unknown} run
+     * @returns {Promise<void>}
+     */
+    enqueueDetachedEfdRetry (retryGate, ctx, run) {
+      /**
+       * @param {() => void} resolve
+       * @returns {void}
+       */
+      const enqueue = (resolve) => {
+        /**
+         * @param {boolean} shouldRun
+         * @returns {void}
+         */
+        const onDecision = (shouldRun) => {
+          if (!shouldRun) {
+            ctx.isDiscardedEfdRetry = true
+            resolve()
+            return
+          }
+
+          /**
+           * @type {() => void}
+           */
+          let start
+          const startPromise = new Promise(resolve => {
+            start = resolve
+          })
+          const retry = { ctx, resolve, start }
+          /**
+           * @param {unknown} error
+           * @returns {void}
+           */
+          const onRejected = (error) => {
+            retry.ctx.detachedEfdRetryError = error
+            this.finishDetachedEfdRetry(retry)
+          }
+          startPromise.then(() => this.runDetachedEfdRetryWithTimeout(ctx, run)).then(
+            () => this.finishDetachedEfdRetry(retry),
+            onRejected
+          )
+          this.#detachedEfdRetryQueue ??= []
+          this.#detachedEfdRetryQueue.push(retry)
+          this.drainDetachedEfdRetries()
+        }
+        retryGate.promise.then(onDecision)
+      }
+      return new Promise(enqueue)
+    }
+
+    /**
+     * Applies the timeout Jest 28/29 cannot start around a detached concurrent retry body.
+     *
+     * @param {object} ctx
+     * @param {() => unknown} run
+     * @returns {Promise<void>}
+     */
+    runDetachedEfdRetryWithTimeout (ctx, run) {
+      return new Promise((resolve, reject) => {
+        let completed = false
+        const timeoutId = realSetTimeout(() => {
+          if (completed) return
+
+          completed = true
+          reject(new Error(`Exceeded timeout of ${ctx.testTimeout} ms for a test.`))
+        }, ctx.testTimeout)
+
+        const settle = (callback, value) => {
+          if (completed) return
+
+          completed = true
+          timeoutId.unref?.()
+          realClearTimeout(timeoutId)
+          callback(value)
+        }
+
+        let result
+        try {
+          result = run()
+        } catch (error) {
+          settle(reject, error)
+          return
+        }
+        Promise.resolve(result).then(
+          () => settle(resolve),
+          error => settle(reject, error)
+        )
+      })
+    }
+
+    /**
+     * @returns {void}
+     */
+    drainDetachedEfdRetries () {
+      const queue = this.#detachedEfdRetryQueue
+      if (!queue) return
+
+      while (
+        this.#pendingPre30ConcurrentTests === 0 &&
+        this.#activeDetachedEfdRetries < this.#detachedEfdRetryConcurrency &&
+        queue.length > 0
+      ) {
+        this.#activeDetachedEfdRetries++
+        queue.shift().start()
+      }
+    }
+
+    /**
+     * @param {DetachedEfdRetry} retry
+     * @returns {void}
+     */
+    finishDetachedEfdRetry (retry) {
+      this.#activeDetachedEfdRetries--
+      retry.resolve()
+      this.drainDetachedEfdRetries()
+    }
+
+    /**
+     * Preserves Jest's immediate error when a callback test also returns a value.
+     *
+     * @param {() => unknown} run
+     * @param {(error?: Error) => void} done
+     * @returns {void}
+     */
+    runCallbackEfdRetry (run, done) {
+      let result
+      try {
+        result = run()
+      } catch (error) {
+        done(error)
+        return
+      }
+      if (result !== undefined) {
+        done(new Error(
+          "Test functions cannot both take a 'done' callback and return something. " +
+          "Either use a 'done' callback, or return a promise."
+        ))
+      }
+    }
+
     /**
      * Runs a concurrent test function inside its test span context.
      *
@@ -896,24 +1260,51 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         if (typeof done === 'function') {
           done()
         }
+        this.completePre30ConcurrentTest(concurrentTestState)
         return
       }
 
       const runTest = () => testFn.apply(thisArg, args)
-      if (!ctx.isAttemptToFixRetry && !ctx.isEfdRetry) {
-        ctx.isJestRetry = concurrentTestState.numExecutions > 0
+      const runTestInContext = () => {
+        if (!ctx.isAttemptToFixRetry && !ctx.isEfdRetry) {
+          ctx.isJestRetry = concurrentTestState.numExecutions > 0
+        }
+        concurrentTestState.numExecutions++
+
+        if (ctx.currentStore) {
+          return testFnCh.runStores(ctx, runTest)
+        }
+
+        let result
+        testStartCh.runStores(ctx, () => {
+          result = testFnCh.runStores(ctx, runTest)
+        })
+        return result
       }
-      concurrentTestState.numExecutions++
 
-      if (ctx.currentStore) {
-        return testFnCh.runStores(ctx, runTest)
+      const retryGate = ctx.efdRetryGates?.[ctx.efdRetryIndex - 1]
+      if (retryGate && !hasConcurrentTestsStartEvent) {
+        ctx.detachedEfdRetryPromise = this.enqueueDetachedEfdRetry(retryGate, ctx, runTestInContext)
+        return
+      }
+      if (retryGate && typeof args[0] === 'function') {
+        this.runCallbackEfdRetry(runTestInContext, args[0])
+        return
       }
 
+      if (!concurrentTestState.trackEfdCompletion) {
+        return runTestInContext()
+      }
+
+      const startedAt = efdCandidates.has(ctx.name) ? performance.now() : undefined
       let result
-      testStartCh.runStores(ctx, () => {
-        result = testFnCh.runStores(ctx, runTest)
-      })
-      return result
+      try {
+        result = runTestInContext()
+      } catch (error) {
+        this.completePre30ConcurrentTest(concurrentTestState, startedAt)
+        throw error
+      }
+      return this.trackPre30ConcurrentTest(concurrentTestState, result, startedAt)
     }
 
     /**
@@ -1047,30 +1438,63 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       return result
     }
 
-    // Generic function to handle test retries
+    /**
+     * @param {number} retryCount
+     * @returns {EfdRetryGate[]}
+     */
+    createEfdRetryGates (retryCount) {
+      const gates = []
+      for (let retryIndex = 0; retryIndex < retryCount; retryIndex++) {
+        /** @type {(shouldRun: boolean) => void} */
+        let resolveGate
+        const promise = new Promise(resolve => {
+          resolveGate = resolve
+        })
+        gates.push({ promise, resolve: resolveGate })
+      }
+      return gates
+    }
+
+    /**
+     * Registers retry tests while Jest still accepts additions to the test tree.
+     *
+     * @param {JestRetryOptions} options
+     * @returns {number}
+     */
     retryTest ({
+      concurrentTestState: registeredConcurrentTestState,
+      efdRetryGates,
       jestEvent,
-      forceSerial,
+      state,
+      isModified,
       retryCount,
       retryType,
     }) {
-      const { testName, fn, timeout } = jestEvent
+      const { testName, fn, mode, timeout } = jestEvent
       const isAttemptToFixRetry = retryType === 'Test Management (Attempt to Fix)'
       const isEfdRetry = retryType === 'Impacted tests' || retryType === 'Early flake detection'
-      for (let retryIndex = 0; retryIndex < retryCount; retryIndex++) {
-        const concurrentTestState = this.concurrentTestStates.get(fn)
+      const concurrentTestState = registeredConcurrentTestState || this.concurrentTestStates.get(fn)
+      let originalTest
+      if (isEfdRetry && !efdRetryGates) {
+        originalTest = getTestEntries(state.currentDescribeBlock)?.at(-1)
+        if (originalTest?.fn !== fn) {
+          log.error('%s could not retain its original Jest test', retryType)
+          return 0
+        }
+      }
+      let registeredRetryCount = 0
+      for (let retryIndex = 1; retryIndex <= retryCount; retryIndex++) {
+        const testEntries = getTestEntries(state.currentDescribeBlock)
+        const initialTestCount = testEntries?.length
+        let retryFn
         if (concurrentTestState) {
-          const test = forceSerial
-            ? concurrentTestState.serialTest
-            : (
-                concurrentTestState.concurrentTest ||
-                getOriginalConcurrentTest(this.global.test?.concurrent)
-              )
+          const test = concurrentTestState.concurrentTest ??
+            getOriginalConcurrentTest(this.global.test?.concurrent)
           if (typeof test !== 'function') {
             log.error('%s could not retry concurrent test because test is undefined', retryType)
             continue
           }
-          const retryFn = this.createConcurrentTestFn(
+          retryFn = this.createConcurrentTestFn(
             testName,
             concurrentTestState.testFn,
             undefined,
@@ -1078,65 +1502,427 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             {
               concurrentTest: concurrentTestState.concurrentTest,
               concurrentTestThisArg: concurrentTestState.concurrentTestThisArg,
+              efdRetryGates,
+              efdRetryIndex: retryIndex,
               isAttemptToFixRetry,
               isEfdRetry,
-              isModified: concurrentTestState.ctx.isModified,
-              serialTest: concurrentTestState.serialTest,
-              serialTestThisArg: concurrentTestState.serialTestThisArg,
+              isModified: isModified ?? concurrentTestState.ctx.isModified,
               testParameters: concurrentTestState.ctx.testParameters,
+              timeout,
             }
           )
-          const thisArg = forceSerial
-            ? concurrentTestState.serialTestThisArg
-            : concurrentTestState.concurrentTestThisArg
-          test.call(thisArg, testName, retryFn, timeout)
+          test.call(concurrentTestState.concurrentTestThisArg, testName, retryFn, timeout)
         } else if (this.global.test) {
-          this.global.test(testName, fn, timeout)
+          const test = mode === 'only' ? this.global.test.only : this.global.test
+          // The child-count check below proves Jest added a node, so retries can share the test
+          // function instead of retaining one wrapper per scheduled execution.
+          retryFn = fn
+          test(testName, retryFn, timeout)
         } else {
           log.error('%s could not retry test because global.test is undefined', retryType)
+          continue
+        }
+
+        if (isEfdRetry) {
+          const retryTest = testEntries?.length === initialTestCount + 1 ? testEntries.at(-1) : undefined
+          if (retryTest?.fn !== retryFn) {
+            log.error('%s could not retain its pre-registered Jest retry', retryType)
+            continue
+          }
+          efdRetryMetadataByTest.set(retryTest, {
+            isModified: Boolean(isModified),
+            originalTest,
+            retryIndex,
+          })
         }
+        registeredRetryCount++
       }
+      return registeredRetryCount
     }
 
-    // At the `add_test` event we don't have the test object yet, so we can't use it
+    /**
+     * Registers retries for the test Jest just added, keeping a registration failure out of the
+     * `add_test` dispatch, where Jest would report it as a test file error.
+     *
+     * @param {JestRetryOptions} retryOptions
+     * @returns {boolean}
+     */
+    registerRetryTests (retryOptions) {
+      // Jest turns later additions into "Cannot add a test after tests have started running".
+      if (retryOptions.state.hasStarted) {
+        log.error('%s could not register retries after Jest started', retryOptions.retryType)
+        return false
+      }
+
+      const testEntries = getTestEntries(retryOptions.state.currentDescribeBlock)
+      const initialTestCount = testEntries?.length
+      try {
+        const registeredRetryCount = this.retryTest(retryOptions)
+        if (registeredRetryCount === retryOptions.retryCount) return true
+      } catch (error) {
+        log.error('%s could not register retries', retryOptions.retryType, error)
+      }
+
+      if (testEntries && initialTestCount !== undefined) {
+        const retryTests = testEntries.splice(initialTestCount)
+        for (const retryTest of retryTests) {
+          removedRetryTests.add(retryTest)
+          const retryCtx = this.concurrentTestStates.get(retryTest.fn)?.ctx
+          if (retryCtx) {
+            this.removeConcurrentTestContext(retryOptions.testFullName, retryCtx)
+          }
+        }
+        const tests = retryOptions.state.currentDescribeBlock?.tests
+        if (tests) {
+          let writeIndex = 0
+          for (const test of tests) {
+            if (!removedRetryTests.has(test)) {
+              tests[writeIndex++] = test
+            }
+          }
+          tests.length = writeIndex
+        }
+      }
+      this.#efdRetryGatesByName?.delete(retryOptions.testFullName)
+      log.error('%s did not register every retry', retryOptions.retryType)
+      return false
+    }
+
+    /**
+     * Drops the pre-registered EFD retries that exceed the retry count Jest may still run.
+     *
+     * @param {string} testName
+     * @param {object} executedTest The Jest test node that selected the retry count.
+     * @param {number} [retryCount] Retries to keep. Every retry is dropped when omitted.
+     * @returns {number} Retries left to run.
+     */
+    discardEfdRetries (testName, executedTest, retryCount = 0) {
+      const siblings = getTestEntries(executedTest.parent)
+      const executedTestIndex = siblings ? siblings.indexOf(executedTest) : -1
+      if (executedTestIndex === -1) return 0
+
+      const originalTest = efdRetryMetadataByTest.get(executedTest)?.originalTest ?? executedTest
+
+      // Circus iterates children live, so only entries after the test that just ran may move.
+      // Whichever pre-registered slot runs first is the original execution; the next retryCount
+      // slots are its retries, independent of Jest's randomized physical node order.
+      let runnableRetryCount = 0
+      let writeIndex = executedTestIndex + 1
+      for (let readIndex = writeIndex; readIndex < siblings.length; readIndex++) {
+        const sibling = siblings[readIndex]
+        const siblingOriginalTest = efdRetryMetadataByTest.get(sibling)?.originalTest
+        if (sibling === originalTest || siblingOriginalTest === originalTest) {
+          if (runnableRetryCount >= retryCount) {
+            removedRetryTests.add(sibling)
+            const discardedCtx = this.concurrentTestStates.get(sibling.fn)?.ctx
+            if (discardedCtx) {
+              this.removeConcurrentTestContext(testName, discardedCtx)
+            }
+            continue
+          }
+          runnableRetryCount++
+        }
+        siblings[writeIndex++] = sibling
+      }
+      siblings.length = writeIndex
+
+      const tests = executedTest.parent?.tests
+      if (tests) {
+        writeIndex = 0
+        for (const test of tests) {
+          if (!removedRetryTests.has(test)) {
+            tests[writeIndex++] = test
+          }
+        }
+        tests.length = writeIndex
+      }
+      return runnableRetryCount
+    }
+
+    /**
+     * @param {object} describeBlock
+     * @param {boolean} hasFocusedTests
+     * @param {RegExp|undefined} testNamePattern
+     * @returns {number}
+     */
+    markPre30ConcurrentTests (describeBlock, hasFocusedTests, testNamePattern) {
+      if (describeBlock.mode === 'skip') return 0
+
+      let testCount = 0
+      for (const child of describeBlock.children) {
+        if (child.type === 'describeBlock') {
+          testCount += this.markPre30ConcurrentTests(child, hasFocusedTests, testNamePattern)
+          continue
+        }
+        if (
+          child.type !== 'test' ||
+          !child.concurrent ||
+          efdRetryMetadataByTest.has(child) ||
+          isJestTestSkipped(child, hasFocusedTests, testNamePattern)
+        ) {
+          continue
+        }
+
+        const concurrentTestState = this.concurrentTestStates.get(child.fn)
+        if (concurrentTestState) {
+          concurrentTestState.trackEfdCompletion = true
+          testCount++
+        }
+      }
+      return testCount
+    }
+
+    /**
+     * @param {object} describeBlock
+     * @param {object} state
+     * @returns {void}
+     */
+    preparePre30ConcurrentTests (describeBlock, state) {
+      const testNamePattern = state.testNamePattern
+        ? new RegExp(state.testNamePattern.source, state.testNamePattern.flags)
+        : undefined
+      this.#detachedEfdRetryConcurrency = state.maxConcurrency ?? 1
+      this.#detachedEfdRetryQueue = []
+      this.#pendingPre30ConcurrentTests = this.markPre30ConcurrentTests(
+        describeBlock,
+        state.hasFocusedTests,
+        testNamePattern
+      )
+      this.drainDetachedEfdRetries()
+    }
+
+    /**
+     * @param {object[]} tests
+     * @returns {void}
+     */
+    orderConcurrentEfdRetries (tests) {
+      if (!this.#efdRetryGatesByName) return
+
+      const retryTests = []
+      let originalTestIndex = 0
+      for (const test of tests) {
+        if (efdRetryMetadataByTest.has(test)) {
+          retryTests.push(test)
+        } else {
+          tests[originalTestIndex++] = test
+        }
+      }
+      for (const retryTest of retryTests) {
+        tests[originalTestIndex++] = retryTest
+      }
+    }
+
+    /**
+     * @param {string} testName
+     * @param {number} durationMs
+     * @returns {void}
+     */
+    determineEfdRetries (testName, durationMs) {
+      if (efdDeterminedRetries.has(testName)) return
+
+      const retryCount = getEfdRetryCountForDuration(durationMs, this.#earlyFlakeDetectionRetryPolicy)
+      efdDeterminedRetries.set(testName, retryCount)
+      efdExpectedExecutions.set(testName, retryCount + 1)
+      const retryGates = this.#efdRetryGatesByName?.get(testName)
+      if (retryGates) {
+        for (let retryIndex = 0; retryIndex < retryGates.length; retryIndex++) {
+          retryGates[retryIndex].resolve(retryIndex < retryCount)
+        }
+      }
+      if (retryCount === 0) {
+        efdSlowAbortedTests.add(testName)
+      }
+    }
+
+    /**
+     * @returns {void}
+     */
+    removeDiscardedEfdRetries () {
+      if (!this.#discardedEfdRetryTests) return
+
+      for (const retryTest of this.#discardedEfdRetryTests) {
+        const siblings = getTestEntries(retryTest.parent)
+        const retryTestIndex = siblings?.indexOf(retryTest) ?? -1
+        if (retryTestIndex !== -1) {
+          siblings.splice(retryTestIndex, 1)
+        }
+      }
+      this.#discardedEfdRetryTests = undefined
+    }
+
+    // The `add_test` payload has no test node, so derive its full name from the current describe block.
     getTestNameFromAddTestEvent (event, state) {
       const describeSuffix = getRawJestTestName(state.currentDescribeBlock)
       const testName = describeSuffix ? `${describeSuffix} ${event.testName}` : event.testName
       return removeSeedSuffixFromTestName(testName)
     }
 
+    /**
+     * Classifies a newly registered test and pre-registers every retry Jest may need.
+     *
+     * @param {object} event
+     * @param {object} state
+     * @returns {void}
+     */
+    handleAddTestEvent (event, state) {
+      if (event.concurrent) {
+        this.hasConcurrentTests = true
+      }
+      if (event.failing) {
+        return
+      }
+
+      const testFullName = this.getTestNameFromAddTestEvent(event, state)
+      const concurrentTestContexts = this.concurrentTestContexts.get(testFullName)
+      const concurrentTestState = this.concurrentTestStates.get(event.fn) ||
+        concurrentTestContexts?.at(-1)?.concurrentTestState
+      const registeredTest = getTestEntries(state.currentDescribeBlock)?.at(-1)
+      if (concurrentTestState && registeredTest?.fn === event.fn) {
+        testContexts.set(registeredTest, concurrentTestState.ctx)
+      }
+      if (retriedTestsToNumAttempts.has(testFullName)) {
+        return
+      }
+      const isSkipped = event.mode === 'todo' || event.mode === 'skip'
+      const isAttemptToFix = this.isTestManagementTestsEnabled &&
+        this.testManagementTestsForThisSuite?.attemptToFix?.includes(testFullName)
+      const isDisabled = this.isTestManagementTestsEnabled &&
+        this.testManagementTestsForThisSuite?.disabled?.includes(testFullName)
+      if (isAttemptToFix && !isSkipped) {
+        retriedTestsToNumAttempts.set(testFullName, 0)
+        testsToBeRetried.add(testFullName)
+        const retriesRegistered = this.registerRetryTests({
+          concurrentTestState,
+          jestEvent: event,
+          state,
+          retryCount: testManagementAttemptToFixRetries,
+          retryType: 'Test Management (Attempt to Fix)',
+          testFullName,
+        })
+        if (!retriesRegistered) {
+          retriedTestsToNumAttempts.delete(testFullName)
+          testsToBeRetried.delete(testFullName)
+        }
+      }
+
+      const isModified = this.isImpactedTestsEnabled && (
+        concurrentTestState?.ctx?.isModified ||
+        this.isTestModified(event.asyncError, event.fn)
+      )
+      const isNew = this.isKnownTestsEnabled && !this.knownTestsForThisSuite.includes(testFullName)
+
+      if (isNew && !isSkipped && !isAttemptToFix) {
+        newTests.add(testFullName)
+        if (DYNAMIC_NAME_RE.test(testFullName)) {
+          // Populated directly for runInBand; for parallel workers the main process
+          // collects these from the TEST_HAS_DYNAMIC_NAME span tag via worker-report:trace.
+          newTestsWithDynamicNames.add(`${this.testSuite} › ${testFullName}`)
+        }
+      }
+
+      if (
+        isAttemptToFix ||
+        isDisabled ||
+        isSkipped ||
+        !this.isEarlyFlakeDetectionEnabled ||
+        !hasEfdRetries(this.#earlyFlakeDetectionRetryPolicy) ||
+        (!isNew && !isModified)
+      ) {
+        return
+      }
+
+      retriedTestsToNumAttempts.set(testFullName, 0)
+      testsToBeRetried.add(testFullName)
+      const schedulingRetryCount = this.#earlyFlakeDetectionRetryPolicy.schedulingRetryCount
+      const efdRetryGates = concurrentTestState
+        ? this.createEfdRetryGates(schedulingRetryCount)
+        : undefined
+      if (efdRetryGates) {
+        this.#efdRetryGatesByName ??= new Map()
+        this.#efdRetryGatesByName.set(testFullName, efdRetryGates)
+      }
+      const retriesRegistered = this.registerRetryTests({
+        concurrentTestState,
+        efdRetryGates,
+        isModified,
+        jestEvent: event,
+        state,
+        retryCount: schedulingRetryCount,
+        retryType: isModified ? 'Impacted tests' : 'Early flake detection',
+        testFullName,
+      })
+      if (retriesRegistered) {
+        efdCandidates.add(testFullName)
+      } else {
+        retriedTestsToNumAttempts.delete(testFullName)
+        testsToBeRetried.delete(testFullName)
+      }
+    }
+
     async handleTestEvent (event, state) {
       if (isDatadogJestEventHandled(event)) return
       markDatadogJestEventHandled(event)
 
+      if (event.name === 'add_test') {
+        this.handleAddTestEvent(event, state)
+      }
+
       if (super.handleTestEvent) {
         await super.handleTestEvent(event, state)
       }
 
       if (event.name === 'setup') {
         this.wrapConcurrentTest(state)
+        this.bindTestEach(this.global.test)
       }
-      if (event.name === 'setup' && this.global.test) {
-        const environment = this
-        shimmer.wrap(this.global.test, 'each', each => function (...args) {
-          const testParameters = getFormattedJestTestParameters(args)
-          const eachBind = each.apply(this, args)
-          return function (...args) {
-            const [testName] = args
-            environment.setNameToParams(testName, testParameters)
-            return eachBind.apply(this, args)
-          }
-        })
+      if (
+        event.name === 'run_describe_start' &&
+        !hasConcurrentTestsStartEvent &&
+        !event.describeBlock.parent &&
+        this.#efdRetryGatesByName?.size > 0
+      ) {
+        this.preparePre30ConcurrentTests(event.describeBlock, state)
       }
-      if (event.name === 'test_start') {
+      if (event.name === 'concurrent_tests_start') {
+        this.orderConcurrentEfdRetries(event.tests)
+      } else if (event.name === 'test_start') {
         const testName = getJestTestName(event.test)
-        const concurrentTestState = this.concurrentTestStates.get(event.test.fn)
+        let isAttemptToFix = false
+        let isDisabled = false
+        let isQuarantined = false
+        if (this.isTestManagementTestsEnabled) {
+          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(testName)
+          isDisabled = this.testManagementTestsForThisSuite?.disabled?.includes(testName)
+          isQuarantined = this.testManagementTestsForThisSuite?.quarantined?.includes(testName)
+          if (!isAttemptToFix && isDisabled) {
+            event.test.mode = 'skip'
+          }
+        }
+        if (
+          event.test.mode === 'todo' ||
+          isJestTestSkipped(event.test, state.hasFocusedTests, state.testNamePattern)
+        ) {
+          return
+        }
+
+        const registeredConcurrentTestState = testContexts.get(event.test)?.concurrentTestState
+        const concurrentTestState = this.concurrentTestStates.get(event.test.fn) ||
+          registeredConcurrentTestState
         let concurrentCtx = concurrentTestState?.ctx
         if (concurrentCtx) {
           this.removeConcurrentTestContext(testName, concurrentCtx)
         } else {
           concurrentCtx = this.getNextConcurrentTestContext(testName)
         }
+        if (hasConcurrentTestsStartEvent && concurrentCtx?.efdRetryGates) {
+          const retryGate = concurrentCtx.efdRetryGates[concurrentCtx.efdRetryIndex - 1]
+          const shouldRun = await retryGate.promise
+          if (!shouldRun) {
+            concurrentCtx.isDiscardedEfdRetry = true
+            event.test.mode = 'skip'
+            return
+          }
+        }
         if (testsToBeRetried.has(testName)) {
           // This is needed because we're retrying tests with the same name
           this.resetSnapshotState()
@@ -1148,24 +1934,17 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         let numOfAttemptsToFixRetries = null
         const testParameters = concurrentCtx?.testParameters ||
           concurrentTestState?.ctx?.testParameters ||
+          this.testParametersByFunction.get(event.test.fn) ||
           getTestParametersString(this.nameToParams, event.test.name)
 
-        let isAttemptToFix = false
-        let isDisabled = false
-        let isQuarantined = false
-        if (this.isTestManagementTestsEnabled) {
-          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(testName)
-          isDisabled = this.testManagementTestsForThisSuite?.disabled?.includes(testName)
-          isQuarantined = this.testManagementTestsForThisSuite?.quarantined?.includes(testName)
-          if (isAttemptToFix) {
-            numOfAttemptsToFixRetries = retriedTestsToNumAttempts.get(testName)
-            retriedTestsToNumAttempts.set(testName, numOfAttemptsToFixRetries + 1)
-          } else if (isDisabled) {
-            event.test.mode = 'skip'
-          }
+        if (isAttemptToFix) {
+          numOfAttemptsToFixRetries = retriedTestsToNumAttempts.get(testName)
+          retriedTestsToNumAttempts.set(testName, numOfAttemptsToFixRetries + 1)
         }
 
-        let isModified = this.isTestModified(event.test.asyncError, event.test.fn)
+        const efdRetryMetadata = efdRetryMetadataByTest.get(event.test)
+        let isModified = efdRetryMetadata?.isModified ||
+          this.isTestModified(event.test.asyncError, event.test.fn)
         if (concurrentCtx?.isModified || concurrentTestState?.ctx?.isModified) {
           isModified = true
         }
@@ -1174,7 +1953,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           isNewTest = newTests.has(testName)
         }
 
-        const willRunEfd = this.isEarlyFlakeDetectionEnabled && (isNewTest || isModified)
+        const willRunEfd = this.isEarlyFlakeDetectionEnabled &&
+          hasEfdRetries(this.#earlyFlakeDetectionRetryPolicy) &&
+          (isNewTest || isModified)
         event.test[ATR_RETRY_SUPPRESSION_FLAG] = Boolean(isAttemptToFix || willRunEfd)
 
         if (!isAttemptToFix && willRunEfd) {
@@ -1192,9 +1973,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         ctx.testParameters = testParameters
         ctx.frameworkVersion = jestVersion
         ctx.isNew = isNewTest
-        ctx.isEfdRetry = ctx.isEfdRetry || numEfdRetry > 0
+        ctx.isEfdRetry ||= numEfdRetry > 0
+        ctx.efdRetryIndex ??= efdRetryMetadata?.retryIndex
         ctx.isAttemptToFix = isAttemptToFix
-        ctx.isAttemptToFixRetry = ctx.isAttemptToFixRetry || numOfAttemptsToFixRetries > 0
+        ctx.isAttemptToFixRetry ||= numOfAttemptsToFixRetries > 0
         ctx.isJestRetry = isJestRetry
         ctx.isDisabled = isDisabled
         ctx.isQuarantined = isQuarantined
@@ -1301,68 +2083,23 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         })
       }
 
-      if (event.name === 'add_test') {
-        if (event.concurrent) {
-          this.hasConcurrentTests = true
-        }
-
-        if (event.failing) {
-          return
-        }
-
-        const testFullName = this.getTestNameFromAddTestEvent(event, state)
-        const isSkipped = event.mode === 'todo' || event.mode === 'skip'
-        const isAttemptToFix = this.isTestManagementTestsEnabled &&
-          this.testManagementTestsForThisSuite?.attemptToFix?.includes(testFullName)
-        if (
-          isAttemptToFix &&
-          !isSkipped &&
-          !retriedTestsToNumAttempts.has(testFullName)
-        ) {
-          retriedTestsToNumAttempts.set(testFullName, 0)
-          testsToBeRetried.add(testFullName)
-          this.retryTest({
-            jestEvent: event,
-            retryCount: testManagementAttemptToFixRetries,
-            retryType: 'Test Management (Attempt to Fix)',
-          })
+      if (event.name === 'test_done') {
+        const retryCtx = testContexts.get(event.test)
+        if (!hasConcurrentTestsStartEvent && retryCtx?.concurrentTestState) {
+          this.completePre30ConcurrentTest(retryCtx.concurrentTestState)
         }
-        if (!isAttemptToFix && this.isImpactedTestsEnabled) {
-          const concurrentTestState = this.concurrentTestStates.get(event.fn)
-          const isModified = concurrentTestState?.ctx?.isModified ||
-            this.isTestModified(event.asyncError, event.fn)
-          if (isModified && !retriedTestsToNumAttempts.has(testFullName) && this.isEarlyFlakeDetectionEnabled) {
-            retriedTestsToNumAttempts.set(testFullName, 0)
-            testsToBeRetried.add(testFullName)
-            this.retryTest({
-              jestEvent: event,
-              retryCount: earlyFlakeDetectionNumRetries,
-              retryType: 'Impacted tests',
-            })
+        if (retryCtx?.detachedEfdRetryPromise) {
+          await retryCtx.detachedEfdRetryPromise
+          if (retryCtx.detachedEfdRetryError !== undefined) {
+            event.test.errors.push(retryCtx.detachedEfdRetryError)
           }
         }
-        if (!isAttemptToFix && this.isKnownTestsEnabled) {
-          const isNew = !this.knownTestsForThisSuite.includes(testFullName)
-          if (isNew && !isSkipped) {
-            newTests.add(testFullName)
-          }
-          if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(testFullName)) {
-            if (DYNAMIC_NAME_RE.test(testFullName)) {
-              // Populated directly for runInBand; for parallel workers the main process
-              // collects these from the TEST_HAS_DYNAMIC_NAME span tag via worker-report:trace.
-              newTestsWithDynamicNames.add(`${this.testSuite} › ${testFullName}`)
-            }
-            retriedTestsToNumAttempts.set(testFullName, 0)
-            if (this.isEarlyFlakeDetectionEnabled) {
-              testsToBeRetried.add(testFullName)
-              efdNewTestCandidates.add(testFullName)
-              // Cloning is deferred to test_done after the first execution,
-              // when we know the duration and can choose the right retry count.
-            }
-          }
+        if (retryCtx?.isDiscardedEfdRetry) {
+          this.#discardedEfdRetryTests ??= new Set()
+          this.#discardedEfdRetryTests.add(event.test)
+          return
         }
-      }
-      if (event.name === 'test_done') {
+
         const originalError = event.test?.errors?.[0]
         let status = 'pass'
         if (event.test.errors && event.test.errors.length) {
@@ -1410,71 +2147,32 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
 
-        // EFD dynamic cloning: on first execution of a new EFD candidate,
-        // determine the retry count from the test's duration.
+        // The first execution selects how many pre-registered EFD retries remain runnable.
         if (
           this.isEarlyFlakeDetectionEnabled &&
-          this.isKnownTestsEnabled &&
-          efdNewTestCandidates.has(testName) &&
+          efdCandidates.has(testName) &&
           event.test.invocations === 1 &&
           !efdDeterminedRetries.has(testName)
         ) {
-          const durationMs = event.test.duration ?? 0
-          const retryCount = getEfdRetryCount(durationMs, earlyFlakeDetectionSlowTestRetries)
-          efdDeterminedRetries.set(testName, retryCount)
-          if (retryCount > 0) {
-            // Temporarily adjust jest-circus state so that retry tests are registered
-            // into the correct describe block and bypass the "tests have started" guard.
-            //
-            // Problem 1 (jest-circus ≤24): currentDescribeBlock points to ROOT during
-            // execution, and ROOT's tests loop already finished before children ran.
-            //
-            // Problem 2 (jest-circus ≥27): `hasStarted = true` causes `test()` to throw
-            // "Cannot add a test after tests have started running".
-            //
-            // Fix: temporarily point currentDescribeBlock to the test's parent (so retries
-            // land in the still-iterating children array) and set hasStarted = false (so the
-            // guard is bypassed). Both are restored immediately after scheduling the retries.
-            const originalDescribeBlock = state.currentDescribeBlock
-            const originalHasStarted = state.hasStarted
-            state.currentDescribeBlock = event.test.parent ?? originalDescribeBlock
-            state.hasStarted = false
-            this.retryTest({
-              forceSerial: true,
-              jestEvent: {
-                testName: event.test.name,
-                fn: event.test.fn,
-                timeout: event.test.timeout,
-              },
-              retryCount,
-              retryType: 'Early flake detection',
-            })
-            state.currentDescribeBlock = originalDescribeBlock
-            state.hasStarted = originalHasStarted
-          } else {
-            efdSlowAbortedTests.add(testName)
+          this.determineEfdRetries(testName, event.test.duration ?? 0)
+          if (!this.#efdRetryGatesByName?.has(testName)) {
+            this.discardEfdRetries(testName, event.test, efdDeterminedRetries.get(testName))
           }
         }
 
-        let isEfdRetry = false
-        // We'll store the test statuses of the retries
-        if (this.isKnownTestsEnabled) {
-          const isNewTest = newTests.has(testName)
-          if (isNewTest) {
-            if (newTestsTestStatuses.has(testName)) {
-              newTestsTestStatuses.get(testName).push(status)
-              isEfdRetry = true
-            } else {
-              newTestsTestStatuses.set(testName, [status])
-            }
-            const testStatuses = newTestsTestStatuses.get(testName)
-            // Check if this is the last EFD retry.
-            // If it is, we'll set the failedAllTests flag to true if all the tests failed
-            const efdRetryCount = efdDeterminedRetries.get(testName) ?? 0
-            if (efdRetryCount > 0 && testStatuses.length === efdRetryCount + 1 &&
-              testStatuses.every(status => status === 'fail')) {
-              failedAllTests = true
-            }
+        const isEfdRetry = retryCtx?.isEfdRetry === true
+        if (efdCandidates.has(testName)) {
+          let testStatuses = efdTestStatuses.get(testName)
+          if (testStatuses) {
+            testStatuses.push(status)
+          } else {
+            testStatuses = [status]
+            efdTestStatuses.set(testName, testStatuses)
+          }
+          const efdRetryCount = efdDeterminedRetries.get(testName) ?? 0
+          if (efdRetryCount > 0 && testStatuses.length === efdExpectedExecutions.get(testName) &&
+            testStatuses.every(status => status === 'fail')) {
+            failedAllTests = true
           }
         }
 
@@ -1511,6 +2209,16 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           log.warn('"ci:jest:test_done": no context found for test "%s"', testName)
           return
         }
+        if (!isJestWorker) {
+          recordTestManagementExecution({
+            testSuite: ctx.suite,
+            testName: ctx.name,
+            status,
+            isAttemptToFix: ctx.isAttemptToFix,
+            isDisabled: ctx.isDisabled,
+            isQuarantined: ctx.isQuarantined,
+          })
+        }
         if (ctx.concurrentTestState && !ctx.currentStore && !ctx.isDisabled) {
           testStartCh.runStores(ctx, () => {})
         }
@@ -1565,8 +2273,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         if (ctx.concurrentTestState) {
           ctx.currentStore = undefined
         }
-      }
-      if (event.name === 'run_finish') {
+      } else if (event.name === 'run_finish') {
+        this.removeDiscardedEfdRetries()
         for (const [test, errors] of atrSuppressedErrors) {
           // Do not restore errors for non-ATF quarantined tests — they should stay suppressed
           // so Jest doesn't see the failure (prevents --bail from stopping the run).
@@ -1588,16 +2296,31 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
 
         efdDeterminedRetries.clear()
+        efdExpectedExecutions.clear()
         efdSlowAbortedTests.clear()
-        efdNewTestCandidates.clear()
+        efdCandidates.clear()
         newTests.clear()
         retriedTestsToNumAttempts.clear()
         attemptToFixRetriedTestsStatuses.clear()
         testsToBeRetried.clear()
+        this.#efdRetryGatesByName = undefined
+        this.#detachedEfdRetryQueue = undefined
         testSuiteDatadogEnvironments.delete(this.testSuiteAbsolutePath)
-      }
-      if (event.name === 'test_skip' || event.name === 'test_todo') {
+      } else if (event.name === 'test_skip' || event.name === 'test_todo') {
         const testName = getJestTestName(event.test)
+        const retryGates = this.#efdRetryGatesByName?.get(testName)
+        if (retryGates) {
+          if (efdRetryMetadataByTest.has(event.test)) {
+            this.#discardedEfdRetryTests ??= new Set()
+            this.#discardedEfdRetryTests.add(event.test)
+            return
+          }
+          for (const gate of retryGates) {
+            gate.resolve(false)
+          }
+        } else {
+          this.discardEfdRetries(testName, event.test)
+        }
         testSkippedCh.publish({
           test: {
             name: testName,
@@ -1612,18 +2335,18 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
-    getEfdResult ({ testName, isNewTest, isModifiedTest, isEfdRetry, numberOfExecutedRetries }) {
+    getEfdResult ({ testName, isNewTest, isModifiedTest }) {
       const isEfdEnabled = this.isEarlyFlakeDetectionEnabled
-      const isEfdActive = isEfdEnabled && (isNewTest || isModifiedTest)
-      const retryCount = efdDeterminedRetries.get(testName) ?? 0
-      const isSlowAbort = efdSlowAbortedTests.has(testName)
-      const isLastEfdRetry = (isEfdRetry && numberOfExecutedRetries >= (retryCount + 1)) || isSlowAbort
-      const isFinalEfdTestExecution = isEfdActive && isLastEfdRetry
+      const isEfdActive = isEfdEnabled &&
+        hasEfdRetries(this.#earlyFlakeDetectionRetryPolicy) &&
+        (isNewTest || isModifiedTest)
+      const testStatuses = efdTestStatuses.get(testName)
+      const isFinalEfdTestExecution = isEfdActive &&
+        (efdSlowAbortedTests.has(testName) || testStatuses?.length === (efdExpectedExecutions.get(testName) ?? 0))
 
       let finalStatus
       if (isEfdActive && isFinalEfdTestExecution) {
         // For EFD: The framework reports 'pass' if ANY attempt passed (flaky but not failing)
-        const testStatuses = newTestsTestStatuses.get(testName)
         finalStatus = testStatuses && testStatuses.includes('pass') ? 'pass' : 'fail'
       }
 
@@ -1662,15 +2385,21 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       return { isAttemptToFixEnabled, isFinalAttemptToFixExecution, finalStatus }
     }
 
-    getFinalStatus (testName, status, isNewTest, isModifiedTest, isEfdRetry, isAttemptToFix, numberOfTestInvocations) {
+    getFinalStatus (
+      testName,
+      status,
+      isNewTest,
+      isModifiedTest,
+      isEfdRetry,
+      isAttemptToFix,
+      numberOfTestInvocations
+    ) {
       const numberOfExecutedRetries = retriedTestsToNumAttempts.get(testName) ?? 0
 
       const efdResult = this.getEfdResult({
         testName,
         isNewTest,
         isModifiedTest,
-        isEfdRetry,
-        numberOfExecutedRetries,
       })
       const atrResult = this.getAtrResult({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations })
       const attemptToFixResult = this.getAttemptToFixResult({
@@ -1869,8 +2598,6 @@ function resetLibraryConfiguration () {
   isItrEnabled = false
   isSuitesSkippingEnabled = false
   isEarlyFlakeDetectionEnabled = false
-  earlyFlakeDetectionNumRetries = 0
-  earlyFlakeDetectionSlowTestRetries = {}
   earlyFlakeDetectionFaultyThreshold = 30
   isEarlyFlakeDetectionFaulty = false
   isKnownTestsEnabled = false
@@ -1898,8 +2625,8 @@ function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
   hasUnskippableSuites = jestSuitesToRun.hasUnskippableSuites
   hasForcedToRunSuites = jestSuitesToRun.hasForcedToRunSuites
 
-  isSuitesSkipped = jestSuitesToRun.suitesToRun.length !== originalTests.length
-  numSkippedSuites = jestSuitesToRun.skippedSuites.length
+  isSuitesSkipped ||= jestSuitesToRun.suitesToRun.length !== originalTests.length
+  numSkippedSuites += jestSuitesToRun.skippedSuites.length
   skippedSuitesCoverage = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
     ? skippableSuitesCoverage
     : {}
@@ -2245,8 +2972,6 @@ function getCliWrapper (isNewJestVersion) {
           isItrEnabled = libraryConfig.isItrEnabled
           isSuitesSkippingEnabled = isItrEnabled && libraryConfig.isSuitesSkippingEnabled
           isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
-          earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
-          earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
           earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
           isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
           isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -2298,12 +3023,11 @@ function getCliWrapper (isNewJestVersion) {
           } = skippableSuitesResponse || await getChannelPromise(skippableSuitesCh)
           if (err) {
             skippableSuitesCoverage = {}
-            skippedSuitesCoverage = {}
           } else {
             skippableSuites = receivedSkippableSuites
             skippableSuitesCoverage = receivedSkippableSuitesCoverage || {}
-            skippedSuitesCoverage = {}
           }
+          skippedSuitesCoverage = {}
         } catch (err) {
           log.error('Jest test-suite skippable error', err)
         }
@@ -2381,15 +3105,24 @@ function getCliWrapper (isNewJestVersion) {
         }
       }
 
-      /** @type {{ efdNames: string[], quarantineNames: string[], totalCount: number } | undefined} */
+      /**
+       * @type {{
+       *   efdNames: string[],
+       *   quarantineNames: string[],
+       *   totalCount: number,
+       *   efdFailureCount: number
+       * } | undefined}
+       */
       let ignoredFailuresSummary
       if (isEarlyFlakeDetectionEnabled) {
-        for (const [testName, testStatuses] of newTestsTestStatuses) {
+        for (const [testName, testStatuses] of efdTestStatuses) {
           const { pass, fail } = getTestStats(testStatuses)
           if (pass > 0) { // as long as one passes, we'll consider the test passed
             numEfdFailedTestsToIgnore += fail
-            const suite = fullNameToSuite.get(testName)
-            efdIgnoredNames.push(suite ? `${suite} › ${testName}` : testName)
+            if (fail > 0) {
+              const suite = fullNameToSuite.get(testName)
+              efdIgnoredNames.push(suite ? `${suite} › ${testName}` : testName)
+            }
           }
         }
         // If every test that failed was an EFD retry, we'll consider the suite passed
@@ -2403,6 +3136,7 @@ function getCliWrapper (isNewJestVersion) {
             efdNames: efdIgnoredNames,
             quarantineNames: [],
             totalCount: numEfdFailedTestsToIgnore,
+            efdFailureCount: numEfdFailedTestsToIgnore,
           }
         }
       }
@@ -2475,6 +3209,7 @@ function getCliWrapper (isNewJestVersion) {
               efdNames: [],
               quarantineNames: quarantineIgnoredNames,
               totalCount: totalQuarantineFailures,
+              efdFailureCount: 0,
             }
           }
         }
@@ -2500,6 +3235,7 @@ function getCliWrapper (isNewJestVersion) {
             efdNames: efdIgnoredNames,
             quarantineNames: quarantineIgnoredNames,
             totalCount: visibleIgnoredFailures + numSuppressedQuarantinedTests,
+            efdFailureCount: numEfdFailedTestsToIgnore,
           }
         }
       }
@@ -2522,7 +3258,13 @@ function getCliWrapper (isNewJestVersion) {
         await getChannelPromise(codeCoverageReportCh, { rootDir })
       }
 
-      logSessionSummary(ignoredFailuresSummary, getAttemptToFixExecutionsFromJestResults(result))
+      recordTestManagementExecutionsFromJestResults(result, quarantineIgnoredNames)
+      const allTestsSkipped = isSuitesSkipped && numTotalTests === 0 && numTotalTestSuites === 0
+      logSessionSummary(
+        ignoredFailuresSummary,
+        getAttemptToFixExecutionsFromJestResults(result),
+        allTestsSkipped
+      )
 
       resetSuiteSkippingRunState()
 
@@ -2865,7 +3607,7 @@ const DD_TEST_ENVIRONMENT_OPTION_KEYS = [
   '_ddItrCorrelationId',
   '_ddKnownTests',
   '_ddIsEarlyFlakeDetectionEnabled',
-  '_ddEarlyFlakeDetectionSlowTestRetries',
+  '_ddEarlyFlakeDetectionRetryPolicy',
   '_ddRepositoryRoot',
   '_ddTestCodeCoverageEnabled',
   '_ddIsFlakyTestRetriesEnabled',
@@ -3037,9 +3779,7 @@ function wrapJestObject (jestObject, suiteFilePath) {
 
   shimmer.wrap(jestObject, 'mock', mock => function (moduleName) {
     // If the library is mocked with `jest.mock`, we don't want to bypass jest's own require engine
-    if (LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {
-      LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.delete(moduleName)
-    }
+    LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.delete(moduleName)
     recordMockedFile(suiteFilePath, moduleName)
     return mock.apply(this, arguments)
   })