@@ -1019,12 +1019,20 @@ jobs:
       - name: "Build the turbo extension"
         run: make -C turbo-ext -j"$(nproc)"
 
+      - name: "Load the turbo extension through php.ini"
+        # TurboProcessRestarter re-executes the process with the loaded php.ini
+        # to activate OPcache; an extension passed as -d would not survive that,
+        # one from the ini scan dir is loaded again
+        run: |
+          echo "extension=$PWD/turbo-ext/phpstan_turbo.so" | sudo tee "$(php -r 'echo PHP_CONFIG_FILE_SCAN_DIR;')/99-phpstan-turbo.ini"
+          php -r 'exit(extension_loaded("phpstan_turbo") ? 0 : 1);'
+
       - name: "Verify the arena is actually exercised"
         # Without an active extension ArenaCache is the no-op PHP twin and no
         # shared memory exists at all; without fork the workers do not publish in
         # lockstep. Either would make the test below pass for the wrong reason.
         run: |
-          OUTPUT=$(php -d extension="$PWD/turbo-ext/phpstan_turbo.so" bin/phpstan diagnose -c e2e/turbo-arena/phpstan.neon)
+          OUTPUT=$(php bin/phpstan diagnose -c e2e/turbo-arena/phpstan.neon)
           echo "$OUTPUT"
           e2e/bashunit -a contains 'Turbo extension: enabled' "$OUTPUT"
           e2e/bashunit -a contains 'Mechanism:                 fork (pcntl_fork)' "$OUTPUT"
@@ -1035,7 +1043,7 @@ jobs:
         # extension is now always used, so the variable has to be inert -
         # https://github.com/phpstan/phpstan/issues/15143
         run: |
-          OUTPUT=$(PHPSTAN_TURBO=0 php -d extension="$PWD/turbo-ext/phpstan_turbo.so" bin/phpstan diagnose -c e2e/turbo-arena/phpstan.neon)
+          OUTPUT=$(PHPSTAN_TURBO=0 php bin/phpstan diagnose -c e2e/turbo-arena/phpstan.neon)
           echo "$OUTPUT"
           e2e/bashunit -a contains 'Turbo extension: enabled' "$OUTPUT"
 
@@ -1050,17 +1058,16 @@ jobs:
         # must cost sharing, never results - the analysis has to come out exactly
         # as it does with the runner's normal /dev/shm.
         run: |
-          SO="$PWD/turbo-ext/phpstan_turbo.so"
           cd e2e/turbo-arena
           rm -rf tmp
-          php -d extension="$SO" ../../bin/phpstan analyse --no-progress > "$RUNNER_TEMP/reference.txt" 2>&1 || true
+          php ../../bin/phpstan analyse --no-progress > "$RUNNER_TEMP/reference.txt" 2>&1 || true
           tail -5 "$RUNNER_TEMP/reference.txt"
           # a warm disk cache is the worst case: every worker loads and publishes
           # the same entries at the same moment, so duplicates pile up fastest
-          php -d extension="$SO" ../../bin/phpstan clear-result-cache
+          php ../../bin/phpstan clear-result-cache
           sudo mount -o remount,size=32M /dev/shm
           df -h /dev/shm
-          php -d extension="$SO" ../../bin/phpstan analyse --no-progress > "$RUNNER_TEMP/small-shm.txt" 2>&1 || true
+          php ../../bin/phpstan analyse --no-progress > "$RUNNER_TEMP/small-shm.txt" 2>&1 || true
           tail -40 "$RUNNER_TEMP/small-shm.txt"
           # bashunit takes the haystack as a single argv entry, and execve caps
           # one argument at 128 KB - a few hundred KB of analysis output only
@@ -1114,19 +1121,27 @@ jobs:
           ./configure
           make -j"$(nproc)"
 
+      - name: "Load both extensions through php.ini"
+        # TurboProcessRestarter re-executes the process with the loaded php.ini
+        # to activate OPcache; extensions passed as -d would not survive that,
+        # ones from the ini scan dir are loaded again
+        run: |
+          printf 'extension=%s\nextension=%s\n' "$PWD/turbo-ext/phpstan_turbo.so" "$RUNNER_TEMP/forkunsafe/modules/forkunsafe.so" | sudo tee "$(php -r 'echo PHP_CONFIG_FILE_SCAN_DIR;')/99-phpstan-turbo.ini"
+          php -r 'exit(extension_loaded("phpstan_turbo") && extension_loaded("forkunsafe") ? 0 : 1);'
+
       - name: "Verify the extension wedges a forked child on its own"
         # a plain exit() in a forked child must hang, or the test below would
         # pass for the wrong reason
         run: |
           set +e
-          timeout 10 php -d extension="$RUNNER_TEMP/forkunsafe/modules/forkunsafe.so" e2e/fork-unsafe-extension/fork-and-exit.php
+          timeout 10 php e2e/fork-unsafe-extension/fork-and-exit.php
           CODE=$?
           set -e
           e2e/bashunit -a equals "124" "$CODE"
 
       - name: "Verify fork mode is actually used"
         run: |
-          OUTPUT=$(php -d extension="$PWD/turbo-ext/phpstan_turbo.so" -d extension="$RUNNER_TEMP/forkunsafe/modules/forkunsafe.so" bin/phpstan diagnose -c e2e/fork-unsafe-extension/phpstan.neon)
+          OUTPUT=$(php bin/phpstan diagnose -c e2e/fork-unsafe-extension/phpstan.neon)
           echo "$OUTPUT"
           e2e/bashunit -a contains 'Turbo extension: enabled' "$OUTPUT"
           e2e/bashunit -a contains 'Mechanism:                 fork (pcntl_fork)' "$OUTPUT"
@@ -1138,7 +1153,7 @@ jobs:
         run: |
           cd e2e/fork-unsafe-extension
           rm -rf tmp
-          OUTPUT=$(../bashunit -a exit_code "0" "timeout 120 php -d extension=$PWD/../../turbo-ext/phpstan_turbo.so -d extension=$RUNNER_TEMP/forkunsafe/modules/forkunsafe.so ../../bin/phpstan analyse --no-progress -vvv")
+          OUTPUT=$(../bashunit -a exit_code "0" "timeout 120 php ../../bin/phpstan analyse --no-progress -vvv")
           echo "$OUTPUT"
           ../bashunit -a contains 'Mechanism:                 fork (pcntl_fork)' "$OUTPUT"
           ../bashunit -a contains '[OK] No errors' "$OUTPUT"
@@ -2,38 +2,47 @@
 
 namespace PHPStan\Turbo;
 
+use function explode;
 use function extension_loaded;
 use function function_exists;
 use function get_cfg_var;
+use function in_array;
 use function ini_get;
 use function is_string;
 use function max;
 use function pcntl_exec;
 use function php_ini_loaded_file;
+use function strtolower;
+use function trim;
 use const PHP_BINARY;
 
 /**
- * Restarts the main PHPStan process via pcntl_exec() with the distributed
- * turbo extension loaded through -d extension=.
+ * Restarts the main PHPStan process via pcntl_exec() when the process it
+ * was started as is not the one PHPStan wants to run — for either of two
+ * reasons, checked independently.
  *
- * Parallel analysis prefers pcntl_fork()ed workers over spawned ones (see
+ * The distributed turbo extension is available but not loaded. Parallel
+ * analysis prefers pcntl_fork()ed workers over spawned ones (see
  * ForkParallelChecker) — a forked worker inherits the booted process instead
  * of paying a full re-boot. But a forked worker also inherits the parent's
  * loaded extensions: the spawn-time `-d extension=` injection
  * (ProcessHelper) cannot reach it, and dl() cannot load a binary from next
- * to the phar. So when the extension binary is available but not loaded,
- * the whole process is re-executed with it before anything else runs —
- * forked workers then inherit the extension, its stub shadowing, and (when
- * running from a phar) the phar-fork-guard that keeps phar:// reads safe
- * across fork.
+ * to the phar. So the whole process is re-executed with the extension
+ * before anything else runs — forked workers then inherit the extension,
+ * its stub shadowing, and (when running from a phar) the phar-fork-guard
+ * that keeps phar:// reads safe across fork.
  *
- * The restarted process also gets OPcache activated — with JIT pinned off,
- * whatever the user's ini says — so forked workers share the parent's warm
- * opcode cache (see resolveOpcacheArgs()).
+ * The OPcache configuration in effect is not the one PHPStan wants (see
+ * resolveOpcacheArgs()) — usually because OPcache is dormant on CLI, or has
+ * JIT on. The restarted process runs with it activated, JIT pinned off, and
+ * forked workers share the parent's warm opcode cache. This reason stands
+ * on its own so that a php.ini which already loads turbo (a source checkout
+ * with a locally built extension, say) does not leave OPcache dormant just
+ * because there is no extension left to restart for.
  *
- * The restart carries a marker ini entry with the extension path. It doubles
- * as the retry stop (a binary that failed to load leaves the extension
- * unloaded — without the marker the restart would loop) and tells
+ * The restart carries two marker ini entries: RESTARTED_INI is the retry
+ * stop (a binary that failed to load, or an OPcache that could not start,
+ * would otherwise restart forever), and EXTENSION_PATH_INI tells
  * TurboExtensionSelector that spawned workers still need the -d flag
  * (command-line -d flags, unlike php.ini, are not inherited).
  */
@@ -42,6 +51,9 @@ final class TurboProcessRestarter
 
 	public const EXTENSION_PATH_INI = 'phpstan.turboExtensionPath';
 
+	/** Set by the restart so the restarted process never restarts again */
+	public const RESTARTED_INI = 'phpstan.restarted';
+
 	/** Shared memory reserved (not touched) for the opcode cache, in MB — see resolveOpcacheArgs() for the sizing */
 	private const OPCACHE_MEMORY_CONSUMPTION_MB_LIMIT = 256;
 
@@ -80,11 +92,10 @@ public static function getRestartExtensionPath(): ?string
 	 */
 	public static function restartIfSuitable(array $argv): void
 	{
-		if (extension_loaded('phpstan_turbo')) {
-			return;
-		}
-		if (self::getRestartExtensionPath() !== null) {
-			// already restarted and the extension still did not load
+		if (get_cfg_var(self::RESTARTED_INI) !== false) {
+			// already restarted — whatever did not take effect (a binary that
+			// failed to load, an OPcache that could not start) will not on a
+			// second try either
 			return;
 		}
 		if (
@@ -100,8 +111,12 @@ public static function restartIfSuitable(array $argv): void
 			return;
 		}
 
-		$extensionPath = TurboExtensionSelector::findExtension();
-		if ($extensionPath === null) {
+		$extensionPath = extension_loaded('phpstan_turbo') ? null : TurboExtensionSelector::findExtension();
+		$opcacheArgs = self::getOpcacheArgs();
+		if (
+			$extensionPath === null
+			&& !self::resolveOpcacheRestartNeeded($opcacheArgs, self::getCurrentIniValues($opcacheArgs))
+		) {
 			return;
 		}
 
@@ -113,20 +128,82 @@ public static function restartIfSuitable(array $argv): void
 		}
 		$args[] = '-d';
 		$args[] = 'memory_limit=' . ini_get('memory_limit');
-		foreach (self::getOpcacheArgs() as $opcacheArg) {
+		foreach ($opcacheArgs as $opcacheArg) {
 			$args[] = '-d';
 			$args[] = $opcacheArg;
 		}
+		if ($extensionPath !== null) {
+			$args[] = '-d';
+			$args[] = 'extension=' . $extensionPath;
+			$args[] = '-d';
+			$args[] = self::EXTENSION_PATH_INI . '=' . $extensionPath;
+		}
 		$args[] = '-d';
-		$args[] = 'extension=' . $extensionPath;
-		$args[] = '-d';
-		$args[] = self::EXTENSION_PATH_INI . '=' . $extensionPath;
+		$args[] = self::RESTARTED_INI . '=1';
 		foreach ($argv as $arg) {
 			$args[] = $arg;
 		}
 
 		pcntl_exec(PHP_BINARY, $args);
-		// pcntl_exec() returns only on failure — continue without the extension
+		// pcntl_exec() returns only on failure — continue as we are
+	}
+
+	/**
+	 * Whether the OPcache configuration the restart would set differs from
+	 * the one in effect — the second reason to restart, independent of turbo:
+	 * with the extension already loaded through php.ini there would be
+	 * nothing else to restart for, and OPcache would stay dormant.
+	 *
+	 * @param list<string> $opcacheArgs `name=value` entries, see resolveOpcacheArgs()
+	 * @param array<string, string|false> $currentIniValues ini_get() of each of those names
+	 */
+	public static function resolveOpcacheRestartNeeded(array $opcacheArgs, array $currentIniValues): bool
+	{
+		foreach ($opcacheArgs as $opcacheArg) {
+			[$name, $value] = explode('=', $opcacheArg, 2);
+			$current = $currentIniValues[$name] ?? false;
+			if ($current === false) {
+				// unknown directive on this PHP (opcache.jit before 8.0) — nothing a restart could change
+				continue;
+			}
+			if (self::normalizeIniValue($current) !== self::normalizeIniValue($value)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * @param list<string> $opcacheArgs
+	 * @return array<string, string|false>
+	 */
+	private static function getCurrentIniValues(array $opcacheArgs): array
+	{
+		$values = [];
+		foreach ($opcacheArgs as $opcacheArg) {
+			$name = explode('=', $opcacheArg, 2)[0];
+			$values[$name] = ini_get($name);
+		}
+
+		return $values;
+	}
+
+	/**
+	 * The ini parser stores booleans as "1" / "" for php.ini and -d values
+	 * alike; ini_set()-style spellings are folded the same way.
+	 */
+	private static function normalizeIniValue(string $value): string
+	{
+		$value = strtolower(trim($value));
+		if (in_array($value, ['', '0', 'off', 'false', 'no', 'none'], true)) {
+			return '0';
+		}
+		if (in_array($value, ['1', 'on', 'true', 'yes'], true)) {
+			return '1';
+		}
+
+		return $value;
 	}
 
 	/**
 
@@ -108,4 +108,64 @@ private static function withSizes(int $memory, int $interned, int $files): array
 		return $args;
 	}
 
+	/**
+	 * @return iterable<string, array{array<string, string|false>, bool}>
+	 */
+	public static function dataResolveOpcacheRestartNeeded(): iterable
+	{
+		// what the restarted process reads back through ini_get() for the stock args
+		$inEffect = [
+			'opcache.enable' => '1',
+			'opcache.enable_cli' => '1',
+			'opcache.jit' => 'disable',
+			'opcache.jit_buffer_size' => '0',
+			'opcache.validate_timestamps' => '0',
+			'opcache.file_update_protection' => '0',
+			'opcache.max_file_size' => '0',
+			'opcache.file_cache' => '',
+			'opcache.save_comments' => '1',
+			'opcache.memory_consumption' => '256',
+			'opcache.interned_strings_buffer' => '64',
+			'opcache.max_accelerated_files' => '20000',
+		];
+
+		yield 'already in effect' => [$inEffect, false];
+
+		// php.ini spellings the ini parser leaves as-is versus its "1"/"" for booleans
+		yield 'already in effect, php.ini spellings' => [
+			['opcache.enable' => 'On', 'opcache.validate_timestamps' => '', 'opcache.jit' => 'Disable'] + $inEffect,
+			false,
+		];
+
+		yield 'stock CLI: OPcache dormant' => [
+			['opcache.enable_cli' => '', 'opcache.validate_timestamps' => '1', 'opcache.file_update_protection' => '2', 'opcache.memory_consumption' => '128', 'opcache.interned_strings_buffer' => '8', 'opcache.max_accelerated_files' => '10000'] + $inEffect,
+			true,
+		];
+
+		yield 'OPcache active but JIT on' => [
+			['opcache.jit' => 'tracing', 'opcache.jit_buffer_size' => '64M'] + $inEffect,
+			true,
+		];
+
+		yield 'OPcache active with a file cache' => [
+			['opcache.file_cache' => '/tmp/opcache'] + $inEffect,
+			true,
+		];
+
+		// PHP < 8.0 has no JIT directives — nothing a restart could change there
+		yield 'directive unknown on this PHP' => [
+			['opcache.jit' => false, 'opcache.jit_buffer_size' => false] + $inEffect,
+			false,
+		];
+	}
+
+	/**
+	 * @param array<string, string|false> $currentIniValues
+	 */
+	#[DataProvider('dataResolveOpcacheRestartNeeded')]
+	public function testResolveOpcacheRestartNeeded(array $currentIniValues, bool $expected): void
+	{
+		$this->assertSame($expected, TurboProcessRestarter::resolveOpcacheRestartNeeded(self::STOCK_ARGS, $currentIniValues));
+	}
+
 }