diff --git a/.readme-partials/USING.md b/.readme-partials/USING.md
index 6b070a72..80d8127f 100644
--- a/.readme-partials/USING.md
+++ b/.readme-partials/USING.md
@@ -254,6 +254,17 @@ composer behat -- --stop-on-failure
 composer behat-rerun
 ```
 
+### Running scenarios in parallel
+
+Set `WP_CLI_TEST_PARALLEL` to a number of workers to spread the scenarios over that many Behat processes:
+```bash
+WP_CLI_TEST_PARALLEL=4 composer behat
+```
+
+Every worker but the first gets its own temporary directory, and with it its own home directory, caches and run directories, as well as its own test database, named after the test database with a numeric suffix (`wp_cli_test_1`, `wp_cli_test_2`, ...). Run `composer prepare-tests` once to allow the test user to create these databases. Without that permission, the scenarios are run one after the other, as they are on Windows, when collecting code coverage, or when selecting scenarios by path or name.
+
+Scenarios that rely on resources shared across the system, such as a fixed port or a fixed path in the system's temporary directory, are all run by the first worker, one after the other. `composer behat-rerun` re-runs exactly the scenarios that failed in the last parallel run.
+
 ### Linting the feature files
 
 `composer lint-gherkin` checks `features/` with
diff --git a/bin/install-package-tests b/bin/install-package-tests
index 1c448f4f..1da6267e 100755
--- a/bin/install-package-tests
+++ b/bin/install-package-tests
@@ -150,6 +150,8 @@ install_mysql_db_8_0_plus() {
 	${CLIENT_BINARY} -e "CREATE USER IF NOT EXISTS \`${TEST_USER}\`@'%' IDENTIFIED WITH caching_sha2_password BY '${TEST_PASSWORD}'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
 	${CLIENT_BINARY} -e "GRANT ALL PRIVILEGES ON \`${TEST_DB}\`.* TO '${TEST_USER}'@'%'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
 	${CLIENT_BINARY} -e "GRANT ALL PRIVILEGES ON \`${TEST_DB}_scaffold\`.* TO '${TEST_USER}'@'%'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
+	# The databases of parallel test workers, named after the test database with a numeric suffix.
+	${CLIENT_BINARY} -e "GRANT ALL PRIVILEGES ON \`${TEST_DB}\\_%\`.* TO '${TEST_USER}'@'%'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
 	{ set +ex; } 2> /dev/null # stop printing the commands
 }
 
@@ -159,6 +161,8 @@ install_mysql_db_lower_than_8_0() {
 	${CLIENT_BINARY} -e "CREATE DATABASE IF NOT EXISTS \`${TEST_DB}\`;" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
 	${CLIENT_BINARY} -e "GRANT ALL ON \`${TEST_DB}\`.* TO '${TEST_USER}'@'%' IDENTIFIED BY '${TEST_PASSWORD}'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
 	${CLIENT_BINARY} -e "GRANT ALL ON \`${TEST_DB}_scaffold\`.* TO '${TEST_USER}'@'%' IDENTIFIED BY '${TEST_PASSWORD}'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
+	# The databases of parallel test workers, named after the test database with a numeric suffix.
+	${CLIENT_BINARY} -e "GRANT ALL ON \`${TEST_DB}\\_%\`.* TO '${TEST_USER}'@'%' IDENTIFIED BY '${TEST_PASSWORD}'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
 	{ set +ex; } 2> /dev/null # stop printing the commands
 }
 
@@ -169,6 +173,8 @@ install_mariadb() {
 	${CLIENT_BINARY} -e "CREATE USER IF NOT EXISTS \`${TEST_USER}\`@'%' IDENTIFIED BY '${TEST_PASSWORD}'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
 	${CLIENT_BINARY} -e "GRANT ALL PRIVILEGES ON \`${TEST_DB}\`.* TO '${TEST_USER}'@'%'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
 	${CLIENT_BINARY} -e "GRANT ALL PRIVILEGES ON \`${TEST_DB}_scaffold\`.* TO '${TEST_USER}'@'%'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
+	# The databases of parallel test workers, named after the test database with a numeric suffix.
+	${CLIENT_BINARY} -e "GRANT ALL PRIVILEGES ON \`${TEST_DB}\\_%\`.* TO '${TEST_USER}'@'%'" ${HOST_STRING} -u"${USER}" "${PASSWORD_STRING}"
 }
 
 if [ "${TYPE}" = "MariaDB" ]; then
diff --git a/bin/run-behat-tests b/bin/run-behat-tests
index 6a9d3d4e..b1600b38 100755
--- a/bin/run-behat-tests
+++ b/bin/run-behat-tests
@@ -78,9 +78,10 @@ else
 
 		DBNAME=${WP_CLI_TEST_DBNAME:-wp_cli_test}
 
-		# We need to test the connection.
-		# Let's try to connect to the specific test database.
-		if ! ${DB_CLIENT} ${HOST_STRING} --user="${USER}" ${PASSWORD_ARG} --execute="USE \`${DBNAME}\`;" 2>/dev/null; then
+		# We need to test the connection, and that the test user may create the test database.
+		# The database itself does not need to exist, as the scenarios drop and create it, which
+		# is also why a rerun after a run in parallel workers usually finds it missing.
+		if ! ${DB_CLIENT} ${HOST_STRING} --user="${USER}" ${PASSWORD_ARG} --execute="CREATE DATABASE IF NOT EXISTS \`${DBNAME}\`;" 2>/dev/null; then
 			echo "Warning: Could not connect to the MySQL/MariaDB database."
 			echo "Please make sure the database is running and run 'composer prepare-tests' once to set it up."
 			echo "The tests will continue to be run, but with WP_CLI_TEST_DBTYPE=sqlite."
@@ -270,4 +271,39 @@ for arg in "$@"; do
 	fi
 done
 
+# Run the scenarios in parallel workers when WP_CLI_TEST_PARALLEL is set to their number.
+# Every worker but the first uses its own test database, which the test user needs
+# to be allowed to create, as set up by "composer prepare-tests".
+PARALLEL="${WP_CLI_TEST_PARALLEL-}"
+
+# A rerun after a parallel run covers exactly the scenarios that failed in it, which only the
+# parallel runner knows, whether or not WP_CLI_TEST_PARALLEL is set for the rerun as well.
+for arg in "$@"; do
+	if [ "$arg" = "--rerun" ] && [ -f "${TMPDIR:-/tmp}/wp-cli-test-parallel-failures.scenarios" ]; then
+		exec php "$WP_CLI_TESTS_ROOT"/utils/behat-parallel.php 1 --snippets-for="WP_CLI\Tests\Context\FeatureContext" "${FORMAT_ARGS[@]}" "$BEHAT_TAGS" --strict "${BEHAT_EXTRA_ARGS[@]}" -- "$@"
+	fi
+done
+
+case "$(uname -s)" in
+	MINGW*|MSYS*|CYGWIN*)
+		PARALLEL="";;
+esac
+if [ -n "${PARALLEL}" ] && [ "${PARALLEL}" != "1" ]; then
+	if ! is_numeric "${PARALLEL}"; then
+		echo "Warning: WP_CLI_TEST_PARALLEL is not a number of workers, running the scenarios one after the other." >&2
+		PARALLEL=""
+	elif [[ "${WP_CLI_TEST_COVERAGE}" == "true" ]]; then
+		echo "Code coverage is collected, running the scenarios one after the other." >&2
+		PARALLEL=""
+	elif [ "${WP_CLI_TEST_DBTYPE-}" != "sqlite" ] && ! ${DB_CLIENT} ${HOST_STRING} --user="${USER}" ${PASSWORD_ARG} --execute="CREATE DATABASE IF NOT EXISTS \`${DBNAME}_1\`; DROP DATABASE \`${DBNAME}_1\`;" 2>/dev/null; then
+		echo "Warning: The test user cannot create the databases of parallel workers, running the scenarios one after the other." >&2
+		echo "Run 'composer prepare-tests' once to allow it." >&2
+		PARALLEL=""
+	fi
+fi
+
+if [ -n "${PARALLEL}" ] && [ "${PARALLEL}" != "1" ]; then
+	exec php "$WP_CLI_TESTS_ROOT"/utils/behat-parallel.php "${PARALLEL}" --snippets-for="WP_CLI\Tests\Context\FeatureContext" "${FORMAT_ARGS[@]}" "$BEHAT_TAGS" --strict "${BEHAT_EXTRA_ARGS[@]}" -- "$@"
+fi
+
 vendor/bin/behat --snippets-for="WP_CLI\Tests\Context\FeatureContext" "${FORMAT_ARGS[@]}" "$BEHAT_TAGS" --strict "${BEHAT_EXTRA_ARGS[@]}" "$@"
diff --git a/phpcs.xml.dist b/phpcs.xml.dist
index cad05419..e94e5418 100644
--- a/phpcs.xml.dist
+++ b/phpcs.xml.dist
@@ -79,9 +79,11 @@
 		 so this file does not have to comply with WP naming conventions. -->
 	<rule ref="WordPress.NamingConventions.PrefixAllGlobals">
 		<exclude-pattern>*/utils/behat-tags\.php$</exclude-pattern>
+		<exclude-pattern>*/utils/behat-parallel\.php$</exclude-pattern>
 	</rule>
 	<rule ref="WordPress.WP.GlobalVariablesOverride">
 		<exclude-pattern>*/utils/behat-tags\.php$</exclude-pattern>
+		<exclude-pattern>*/utils/behat-parallel\.php$</exclude-pattern>
 	</rule>
 
 	<!-- This is a procedural stand-alone file that is adding polyfills when
diff --git a/src/Context/FeatureContext.php b/src/Context/FeatureContext.php
index ba8ae9f5..7c1a6e6a 100644
--- a/src/Context/FeatureContext.php
+++ b/src/Context/FeatureContext.php
@@ -481,7 +481,9 @@ private static function get_process_env_variables(): array {
 
 		$env = array_merge( $_ENV, $env );
 
-		foreach ( [ 'TEMP', 'TMP', 'SystemRoot', 'windir' ] as $key ) {
+		// Keep the launched processes in the same temporary directory as the tests, which differs per
+		// parallel worker. WordPress saves downloads under fixed names there, which would clash otherwise.
+		foreach ( [ 'TMPDIR', 'TEMP', 'TMP', 'SystemRoot', 'windir' ] as $key ) {
 			$value = getenv( $key );
 			if ( false !== $value ) {
 				$env[ $key ] = $value;
diff --git a/utils/behat-parallel.php b/utils/behat-parallel.php
new file mode 100644
index 00000000..86c13c8c
--- /dev/null
+++ b/utils/behat-parallel.php
@@ -0,0 +1,336 @@
+<?php
+/**
+ * Run the Behat scenarios of a project in several parallel workers.
+ *
+ * Used by `run-behat-tests` when WP_CLI_TEST_PARALLEL is set to a number of workers greater than 1.
+ *
+ * Every worker but the first gets its own temporary directory, and with it its own home directory,
+ * caches and run directories, as well as its own test database. The first worker runs with the
+ * environment as it is, and takes all scenarios that rely on resources shared across the system,
+ * such as fixed ports or fixed paths in the system's temporary directory.
+ *
+ * Scenarios are distributed by their expected cost, so that the workers finish at about the same time.
+ * The scenarios that failed are recorded, so that `rerun-behat-tests` can run exactly those again.
+ *
+ * Usage: php behat-parallel.php <workers> <behat arguments> -- <arguments passed to run-behat-tests>
+ */
+
+use Behat\Gherkin\Filter\TagFilter;
+use Behat\Gherkin\Keywords\CachedArrayKeywords;
+use Behat\Gherkin\Lexer;
+use Behat\Gherkin\Node\FeatureNode;
+use Behat\Gherkin\Node\PyStringNode;
+use Behat\Gherkin\Node\ScenarioInterface;
+use Behat\Gherkin\Node\TableNode;
+use Behat\Gherkin\Parser;
+
+/**
+ * Scenarios whose steps match this are run by the first worker, one after the other.
+ *
+ * They use fixed ports, background processes, the scaffold test database or fixed paths in the
+ * system's temporary directory, any of which would clash between workers.
+ */
+const WP_CLI_TESTS_SHARED_RESOURCES = '#localhost:\d+|127\.0\.0\.1:\d+|built-in web server|launch in the background|\bwp server\b|_scaffold\b|install-wp-tests|/tmp/#';
+
+/**
+ * Get the file that holds the scenarios which failed in the last parallel run.
+ *
+ * @return string
+ */
+function wp_cli_tests_failures_file() {
+	return sys_get_temp_dir() . '/wp-cli-test-parallel-failures.scenarios';
+}
+
+/**
+ * Run Behat in the current process' environment and exit with its exit code.
+ *
+ * @param array<string> $args
+ */
+function wp_cli_tests_run_behat_and_exit( array $args ) {
+	$command = escapeshellarg( PHP_BINARY ) . ' vendor/bin/behat ' . implode( ' ', array_map( 'escapeshellarg', $args ) );
+	passthru( $command, $exit_code );
+	exit( $exit_code );
+}
+
+/**
+ * Load the Gherkin parser of the Behat installation.
+ *
+ * @return Parser
+ */
+function wp_cli_tests_gherkin_parser() {
+	if ( method_exists( CachedArrayKeywords::class, 'withDefaultKeywords' ) ) {
+		$keywords = CachedArrayKeywords::withDefaultKeywords();
+	} else {
+		// Older versions of behat/gherkin ship the keywords file in their root folder.
+		$dir = dirname( (string) ( new ReflectionClass( CachedArrayKeywords::class ) )->getFileName() );
+		while ( ! file_exists( $dir . '/i18n.php' ) && dirname( $dir ) !== $dir ) {
+			$dir = dirname( $dir );
+		}
+		$keywords = new CachedArrayKeywords( $dir . '/i18n.php' );
+	}
+
+	return new Parser( new Lexer( $keywords ) );
+}
+
+/**
+ * Get the text of a list of steps, including their arguments.
+ *
+ * @param array<\Behat\Gherkin\Node\StepNode> $steps
+ * @return string
+ */
+function wp_cli_tests_steps_text( array $steps ) {
+	$text = '';
+	foreach ( $steps as $step ) {
+		$text .= $step->getText() . "\n";
+		foreach ( $step->getArguments() as $argument ) {
+			if ( $argument instanceof PyStringNode ) {
+				$text .= $argument->getRaw() . "\n";
+			} elseif ( $argument instanceof TableNode ) {
+				$text .= $argument->getTableAsString() . "\n";
+			}
+		}
+	}
+	return $text;
+}
+
+/**
+ * Collect the scenarios to run, with their expected cost and whether they need the first worker.
+ *
+ * @param string $features_folder
+ * @param string $tags            Behat tag expression, without the --tags= prefix.
+ * @return array<array{path: string, cost: int, shared: bool}>
+ */
+function wp_cli_tests_collect_scenarios( $features_folder, $tags ) {
+	$parser    = wp_cli_tests_gherkin_parser();
+	$filter    = '' !== $tags ? new TagFilter( $tags ) : null;
+	$scenarios = [];
+
+	$files = glob( $features_folder . '/*.feature' );
+	sort( $files );
+
+	foreach ( $files as $file ) {
+		$feature = $parser->parse( (string) file_get_contents( $file ), (string) realpath( $file ) );
+
+		if ( ! $feature instanceof FeatureNode ) {
+			continue;
+		}
+
+		$background = $feature->hasBackground() ? wp_cli_tests_steps_text( $feature->getBackground()->getSteps() ) : '';
+
+		foreach ( $feature->getScenarios() as $scenario ) {
+			/** @var ScenarioInterface $scenario */
+			if ( null !== $filter && ! $filter->isScenarioMatch( $feature, $scenario ) ) {
+				continue;
+			}
+
+			$text = $background . wp_cli_tests_steps_text( $scenario->getSteps() );
+
+			// Every step costs about the same, except for setting up WordPress, Composer projects and Phars.
+			$runs = $scenario instanceof \Behat\Gherkin\Node\OutlineNode ? max( 1, count( $scenario->getExamples() ) ) : 1;
+			$cost = $runs * (
+				substr_count( $text, "\n" )
+				+ 10 * preg_match_all( '/^a WP .*install/m', $text )
+				+ 40 * preg_match_all( '/^a WP .*install.* with Composer|^a dependency on current wp-cli|^a (new|downloaded) Phar|composer (require|install|update)/m', $text )
+			);
+
+			$scenarios[] = [
+				'path'   => $file . ':' . $scenario->getLine(),
+				'cost'   => $cost,
+				'shared' => (bool) preg_match( WP_CLI_TESTS_SHARED_RESOURCES, $text ),
+			];
+		}
+	}
+
+	return $scenarios;
+}
+
+/**
+ * Distribute the scenarios over the workers, the most expensive first.
+ *
+ * @param array<array{path: string, cost: int, shared: bool}> $scenarios
+ * @param int $workers
+ * @return array<int, array<string>> Scenario paths per worker.
+ */
+function wp_cli_tests_distribute( array $scenarios, $workers ) {
+	$shards = array_fill( 0, $workers, [] );
+	$load   = array_fill( 0, $workers, 0 );
+
+	foreach ( $scenarios as $scenario ) {
+		if ( $scenario['shared'] ) {
+			$shards[0][] = $scenario['path'];
+			$load[0]    += $scenario['cost'];
+		}
+	}
+
+	$independent = array_values(
+		array_filter(
+			$scenarios,
+			static function ( $scenario ) {
+				return ! $scenario['shared'];
+			}
+		)
+	);
+
+	usort(
+		$independent,
+		static function ( $a, $b ) {
+			return $b['cost'] - $a['cost'];
+		}
+	);
+
+	foreach ( $independent as $scenario ) {
+		$worker              = (int) array_search( min( $load ), $load, true );
+		$shards[ $worker ][] = $scenario['path'];
+		$load[ $worker ]    += $scenario['cost'];
+	}
+
+	return $shards;
+}
+
+$args = array_slice( $argv, 1 );
+
+$workers = (int) array_shift( $args );
+
+$separator  = array_search( '--', $args, true );
+$behat_args = false === $separator ? $args : array_slice( $args, 0, $separator );
+$user_args  = false === $separator ? [] : array_slice( $args, $separator + 1 );
+$all_args   = array_merge( $behat_args, $user_args );
+
+// A rerun after a parallel run covers exactly the scenarios that failed in it.
+$rerun = array_search( '--rerun', $user_args, true );
+if ( false !== $rerun && file_exists( wp_cli_tests_failures_file() ) ) {
+	unset( $user_args[ $rerun ] );
+	$failures = wp_cli_tests_failures_file();
+	$copy     = $failures . '.' . getmypid() . '.scenarios';
+	rename( $failures, $copy );
+	register_shutdown_function( 'unlink', $copy );
+	$command = escapeshellarg( PHP_BINARY ) . ' vendor/bin/behat ' . implode( ' ', array_map( 'escapeshellarg', array_merge( $behat_args, array_values( $user_args ), [ $copy ] ) ) );
+	passthru( $command, $exit_code );
+	exit( $exit_code );
+}
+
+// Paths, name filters and reruns select their own scenarios, so run them as they are.
+$selects_scenarios = false;
+foreach ( $user_args as $arg ) {
+	if ( '' === $arg || '-' !== $arg[0] || in_array( $arg, [ '--rerun', '--rerun-only' ], true ) || 0 === strpos( $arg, '--name' ) || '-n' === $arg ) {
+		$selects_scenarios = true;
+	}
+}
+
+if ( $workers < 2 || DIRECTORY_SEPARATOR === '\\' || $selects_scenarios ) {
+	wp_cli_tests_run_behat_and_exit( $all_args );
+}
+
+require getcwd() . '/vendor/autoload.php';
+
+$tags = '';
+foreach ( $behat_args as $arg ) {
+	if ( 0 === strpos( $arg, '--tags=' ) ) {
+		$tags = substr( $arg, strlen( '--tags=' ) );
+	}
+}
+
+$features_folder = getenv( 'BEHAT_FEATURES_FOLDER' ) ?: 'features';
+$scenarios       = wp_cli_tests_collect_scenarios( $features_folder, $tags );
+$workers         = min( $workers, max( 1, count( $scenarios ) ) );
+
+if ( $workers < 2 ) {
+	wp_cli_tests_run_behat_and_exit( $all_args );
+}
+
+$shards = wp_cli_tests_distribute( $scenarios, $workers );
+// Kept between runs, so that the workers' caches stay warm and failed scenarios can be inspected.
+$base_dir = sys_get_temp_dir() . '/wp-cli-test-parallel-' . substr( md5( (string) getcwd() ), 0, 8 );
+$db_name  = getenv( 'WP_CLI_TEST_DBNAME' ) ?: 'wp_cli_test';
+
+if ( ! is_dir( $base_dir ) ) {
+	mkdir( $base_dir, 0777, true );
+}
+
+printf( "Running %d scenarios in %d parallel workers.\n", count( $scenarios ), $workers );
+
+$procs = [];
+foreach ( $shards as $index => $paths ) {
+	$list = "{$base_dir}/worker-{$index}.scenarios";
+	file_put_contents( $list, implode( "\n", $paths ) . "\n" );
+
+	$env = getenv();
+
+	if ( $index > 0 ) {
+		$env['TMPDIR']             = "{$base_dir}/worker-{$index}";
+		$env['WP_CLI_TEST_DBNAME'] = "{$db_name}_{$index}";
+		if ( ! is_dir( $env['TMPDIR'] ) ) {
+			mkdir( $env['TMPDIR'] );
+		}
+	}
+
+	$output  = "{$base_dir}/worker-{$index}.log";
+	$command = escapeshellarg( PHP_BINARY ) . ' vendor/bin/behat ' . implode( ' ', array_map( 'escapeshellarg', array_merge( $all_args, [ $list ] ) ) );
+
+	$procs[ $index ] = [
+		'proc'   => proc_open(
+			$command,
+			[
+				0 => [ 'file', '/dev/null', 'r' ],
+				1 => [ 'file', $output, 'w' ],
+				2 => [ 'file', $output, 'a' ],
+			],
+			$pipes,
+			null,
+			$env
+		),
+		'output' => $output,
+		'start'  => microtime( true ),
+	];
+}
+
+$exit_code = 0;
+$failed    = [];
+$pending   = $procs;
+
+while ( $pending ) {
+	foreach ( $pending as $index => $worker ) {
+		$status = proc_get_status( $worker['proc'] );
+
+		if ( $status['running'] ) {
+			continue;
+		}
+
+		unset( $pending[ $index ] );
+		proc_close( $worker['proc'] );
+
+		$code      = $status['exitcode'];
+		$exit_code = max( $exit_code, $code );
+		$output    = (string) file_get_contents( $worker['output'] );
+
+		printf( "\n--- Worker %d (%d scenarios, %.1fs, exit code %d)\n\n%s\n", $index, count( $shards[ $index ] ), microtime( true ) - $worker['start'], $code, rtrim( $output ) );
+
+		// Behat numbers the failed scenarios and examples, followed by their path and line.
+		// Older versions list them below a "Failed scenarios" heading instead.
+		$paths = [];
+		if ( preg_match_all( '/^\d+ [^#\n]*#\s*(\S+:\d+)\s*$/m', $output, $matches ) ) {
+			$paths = $matches[1];
+		} elseif ( preg_match( '/--- Failed scenarios:\s*\n((?:[ \t]+\S+:\d+.*\n?)+)/', $output, $matches ) ) {
+			$paths = preg_replace( '/^\s*(\S+:\d+).*$/', '$1', preg_split( '/\n/', trim( $matches[1] ) ) );
+		}
+
+		if ( $paths ) {
+			$failed = array_merge( $failed, $paths );
+		} elseif ( 0 !== $code ) {
+			// Without a list of failures, rerun everything this worker ran.
+			$failed = array_merge( $failed, $shards[ $index ] );
+		}
+	}
+
+	if ( $pending ) {
+		usleep( 200000 );
+	}
+}
+
+if ( $failed ) {
+	file_put_contents( wp_cli_tests_failures_file(), implode( "\n", array_unique( $failed ) ) . "\n" );
+} elseif ( file_exists( wp_cli_tests_failures_file() ) ) {
+	unlink( wp_cli_tests_failures_file() );
+}
+
+exit( $exit_code );