wip

.github/workflows/tests.yml

@@ -76,3 +76,21 @@ jobs:
 
     - name: Integration Tests
       run: composer test:integration
+
+    # tests-tia records coverage inside its sandbox, which requires
+    # pcov (or xdebug) in the process PHP. The main setup-php step is
+    # `coverage: none` for speed — re-enable pcov here just for the
+    # TIA step. Cheap: pcov startup is near-zero.
+    - name: Enable pcov for TIA
+      uses: shivammathur/setup-php@v2
+      with:
+        php-version: ${{ matrix.php }}
+        tools: composer:v2
+        coverage: pcov
+        extensions: sockets
+
+    - name: TIA End-to-End Tests
+      # Black-box tests drive Pest `--tia` against a throw-away sandbox.
+      # First scenario takes ~60s (composer-installs the host Pest into a
+      # cached template); subsequent clones are cheap.
+      run: composer test:tia

bin/pest

@@ -142,6 +142,15 @@ use Symfony\Component\Console\Output\ConsoleOutput;
 
     // Get $rootPath based on $autoloadPath
     $rootPath = dirname($autoloadPath, 2);
+
+    // Re-execs PHP without Xdebug on TIA replay runs so repeat `--tia`
+    // invocations aren't slowed by a coverage driver they don't use. Plain
+    // `pest` runs are left alone — users may rely on Xdebug for IDE
+    // breakpoints, step-through debugging, or custom tooling. See
+    // XdebugGuard for the full decision (coverage / tia-rebuild / Xdebug
+    // mode gates).
+    \Pest\Support\XdebugGuard::maybeDrop($rootPath);
+
     $input = new ArgvInput;
 
     $testSuite = TestSuite::getInstance(

composer.json

@@ -19,18 +19,19 @@
     "require": {
         "php": "^8.3.0",
         "brianium/paratest": "^7.20.0",
-        "nunomaduro/collision": "^8.9.3",
+        "composer/xdebug-handler": "^3.0.5",
+        "nunomaduro/collision": "^8.9.4",
         "nunomaduro/termwind": "^2.4.0",
         "pestphp/pest-plugin": "^4.0.0",
         "pestphp/pest-plugin-arch": "^4.0.2",
         "pestphp/pest-plugin-mutate": "^4.0.1",
         "pestphp/pest-plugin-profanity": "^4.2.1",
-        "phpunit/phpunit": "^12.5.20",
+        "phpunit/phpunit": "^12.5.23",
         "symfony/process": "^7.4.8|^8.0.8"
     },
     "conflict": {
         "filp/whoops": "<2.18.3",
-        "phpunit/phpunit": ">12.5.20",
+        "phpunit/phpunit": ">12.5.23",
         "sebastian/exporter": "<7.0.0",
         "webmozart/assert": "<1.11.0"
     },
@@ -92,6 +93,7 @@
         "test:inline": "php bin/pest --configuration=phpunit.inline.xml",
         "test:parallel": "php bin/pest --exclude-group=integration --parallel --processes=3",
         "test:integration": "php bin/pest --group=integration -v",
+        "test:tia": "php bin/pest --configuration=tests-tia/phpunit.xml",
         "update:snapshots": "REBUILD_SNAPSHOTS=true php bin/pest --update-snapshots",
         "test": [
             "@test:lint",
@@ -99,7 +101,8 @@
             "@test:type:coverage",
             "@test:unit",
             "@test:parallel",
-            "@test:integration"
+            "@test:integration",
+            "@test:tia"
         ]
     },
     "extra": {

src/Bootstrappers/BootSubscribers.php

@@ -28,6 +28,13 @@ final readonly class BootSubscribers implements Bootstrapper
         Subscribers\EnsureTiaCoverageIsRecorded::class,
         Subscribers\EnsureTiaCoverageIsFlushed::class,
         Subscribers\EnsureTiaResultsAreCollected::class,
+        Subscribers\EnsureTiaResultIsRecordedOnPassed::class,
+        Subscribers\EnsureTiaResultIsRecordedOnFailed::class,
+        Subscribers\EnsureTiaResultIsRecordedOnErrored::class,
+        Subscribers\EnsureTiaResultIsRecordedOnSkipped::class,
+        Subscribers\EnsureTiaResultIsRecordedOnIncomplete::class,
+        Subscribers\EnsureTiaResultIsRecordedOnRisky::class,
+        Subscribers\EnsureTiaAssertionsAreRecordedOnFinished::class,
     ];
 
     /**

src/Concerns/Testable.php

@@ -5,17 +5,17 @@ declare(strict_types=1);
 namespace Pest\Concerns;
 
 use Closure;
-use Pest\Contracts\Plugins\BeforeEachable;
 use Pest\Exceptions\DatasetArgumentsMismatch;
 use Pest\Panic;
-use Pest\Plugin\Loader;
-use Pest\Plugins\Tia\CachedTestResult;
+use Pest\Plugins\Tia;
 use Pest\Preset;
 use Pest\Support\ChainableClosure;
+use Pest\Support\Container;
 use Pest\Support\ExceptionTrace;
 use Pest\Support\Reflection;
 use Pest\Support\Shell;
 use Pest\TestSuite;
+use PHPUnit\Framework\AssertionFailedError;
 use PHPUnit\Framework\Attributes\PostCondition;
 use PHPUnit\Framework\IncompleteTest;
 use PHPUnit\Framework\SkippedTest;
@@ -238,29 +238,6 @@ trait Testable
 
         $this->__cachedPass = false;
 
-        /** @var BeforeEachable $plugin */
-        foreach (Loader::getPlugins(BeforeEachable::class) as $plugin) {
-            $cached = $plugin->beforeEach(self::$__filename, $this::class.'::'.$this->name());
-
-            if ($cached instanceof CachedTestResult) {
-                if ($cached->isSuccess()) {
-                    $this->__cachedPass = true;
-
-                    return;
-                }
-
-                // Non-success: throw appropriate exception. PHPUnit catches
-                // it in runBare() and marks the test with the correct status.
-                // This makes skips, failures, incompletes, todos appear in
-                // output exactly as if the test ran.
-                match ($cached->status) {
-                    1 => $this->markTestSkipped($cached->message),     // skip / todo
-                    2 => $this->markTestIncomplete($cached->message),  // incomplete
-                    default => throw new \PHPUnit\Framework\AssertionFailedError($cached->message ?: 'Cached failure'),
-                };
-            }
-        }
-
         $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
 
         $description = $method->description;
@@ -293,6 +270,49 @@ trait Testable
         self::$__latestIssues = $method->issues;
         self::$__latestPrs = $method->prs;
 
+        // TIA replay short-circuit. Runs AFTER dataset/description/
+        // assignee metadata is populated so output and filtering still
+        // see the correct test name + tags on a cache hit, but BEFORE
+        // `parent::setUp()` and `beforeEach` so we skip the user's
+        // fixture setup (which is the whole point of replay — avoid
+        // paying for work whose outcome we already know).
+        /** @var Tia $tia */
+        $tia = Container::getInstance()->get(Tia::class);
+        $cached = $tia->getCachedResult(self::$__filename, $this::class.'::'.$this->name());
+
+        if ($cached !== null) {
+            if ($cached->isSuccess()) {
+                $this->__cachedPass = true;
+
+                return;
+            }
+
+            // Risky tests have no public PHPUnit hook to replay as-risky.
+            // Best available: short-circuit as a pass so the test doesn't
+            // misreport as a failure. Aggregate risky totals won't
+            // survive replay — accepted trade-off until PHPUnit grows a
+            // programmatic risky-marker API.
+            if ($cached->isRisky()) {
+                $this->__cachedPass = true;
+
+                return;
+            }
+
+            // Non-success: throw the matching PHPUnit exception. Runner
+            // catches it and marks the test with the correct status so
+            // skips, failures, incompletes and todos appear in output
+            // exactly as they did in the cached run.
+            if ($cached->isSkipped()) {
+                $this->markTestSkipped($cached->message());
+            }
+
+            if ($cached->isIncomplete()) {
+                $this->markTestIncomplete($cached->message());
+            }
+
+            throw new AssertionFailedError($cached->message() ?: 'Cached failure');
+        }
+
         parent::setUp();
 
         $beforeEach = TestSuite::getInstance()->beforeEach->get(self::$__filename)[1];
@@ -368,7 +388,14 @@ trait Testable
     private function __runTest(Closure $closure, ...$args): mixed
     {
         if ($this->__cachedPass) {
-            $this->addToAssertionCount(1);
+            // Feed the exact assertion count captured during the recorded
+            // run so Pest's "Tests: N passed (M assertions)" banner stays
+            // accurate on replay instead of collapsing to 1-per-test.
+            /** @var Tia $tia */
+            $tia = Container::getInstance()->get(Tia::class);
+            $assertions = $tia->getCachedAssertions($this::class.'::'.$this->name());
+
+            $this->addToAssertionCount($assertions > 0 ? $assertions : 1);
 
             return null;
         }

src/Contracts/Plugins/BeforeEachable.php

@@ -1,25 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Contracts\Plugins;
-
-use Pest\Plugins\Tia\CachedTestResult;
-
-/**
- * Plugins implementing this interface are consulted before each test's
- * `setUp()`. The return value controls what happens:
- *
- *   - `null`              → test proceeds normally.
- *   - `CachedTestResult`  → test replays the cached status. For non-success
- *                           statuses the appropriate exception is thrown
- *                           from `setUp` (PHPUnit handles it natively). For
- *                           success, a synthetic assertion is registered and
- *                           the body + tearDown are skipped via a flag.
- *
- * @internal
- */
-interface BeforeEachable
-{
-    public function beforeEach(string $filename, string $testId): ?CachedTestResult;
-}

src/Kernel.php

@@ -13,7 +13,6 @@ use Pest\Plugins\Actions\CallsBoot;
 use Pest\Plugins\Actions\CallsHandleArguments;
 use Pest\Plugins\Actions\CallsHandleOriginalArguments;
 use Pest\Plugins\Actions\CallsTerminable;
-use Pest\Plugins\Tia;
 use Pest\Support\Container;
 use Pest\Support\Reflection;
 use Pest\Support\View;
@@ -37,6 +36,7 @@ final readonly class Kernel
      */
     private const array BOOTSTRAPPERS = [
         Bootstrappers\BootOverrides::class,
+        Plugins\Tia\Bootstrapper::class,
         Bootstrappers\BootSubscribers::class,
         Bootstrappers\BootFiles::class,
         Bootstrappers\BootView::class,
@@ -65,10 +65,7 @@ final readonly class Kernel
             ->add(TestSuite::class, $testSuite)
             ->add(InputInterface::class, $input)
             ->add(OutputInterface::class, $output)
-            ->add(Container::class, $container)
-            ->add(Tia\Recorder::class, new Tia\Recorder)
-            ->add(Tia\WatchPatterns::class, new Tia\WatchPatterns)
-            ->add(Tia\ResultCollector::class, new Tia\ResultCollector);
+            ->add(Container::class, $container);
 
         $kernel = new self(
             new Application,

src/Pest.php

@@ -6,7 +6,7 @@ namespace Pest;
 
 function version(): string
 {
-    return '4.6.1';
+    return '4.6.3';
 }
 
 function testDirectory(string $file = ''): string

src/Plugins/Tia/BaselineSync.php

@@ -0,0 +1,510 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Composer\InstalledVersions;
+use Pest\Plugins\Tia;
+use Pest\Plugins\Tia\Contracts\State;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Process\Process;
+
+/**
+ * Pulls a team-shared TIA baseline on the first `--tia` run so new
+ * contributors and fresh CI workspaces start in replay mode instead of
+ * paying the ~30s record cost.
+ *
+ * Storage: **workflow artifacts**, not releases. A dedicated CI workflow
+ * (conventionally `.github/workflows/tia-baseline.yml`) runs the full
+ * suite under `--tia` and uploads the `.pest/tia/` directory as a named
+ * artifact (`pest-tia-baseline`) containing `graph.json` +
+ * `coverage.bin`. On dev
+ * machines, this class finds the latest successful run of that workflow
+ * and downloads the artifact via `gh`.
+ *
+ * Why artifacts, not releases:
+ *   - No tag is created → no `push` event cascade into CI workflows.
+ *   - No release event → no deploy workflows tied to `release:published`.
+ *   - Retention is run-scoped and tunable (1-90 days) instead of clobbering
+ *     a single floating tag.
+ *   - Publishing is strictly CI-only: artifacts can't be produced from a
+ *     developer's laptop. This enforces the "CI is the authoritative
+ *     publisher" policy that local-publish paths would otherwise erode.
+ *
+ * Fingerprint validation happens back in `Tia::handleParent` after the
+ * blobs are written: a mismatched environment (different PHP version,
+ * composer.lock, etc.) discards the pulled baseline and falls through to
+ * the regular record path.
+ *
+ * @internal
+ */
+final readonly class BaselineSync
+{
+    /**
+     * Conventional workflow filename teams publish from. Not configurable
+     * for MVP — teams that outgrow the default can set
+     * `PEST_TIA_BASELINE_WORKFLOW` later.
+     */
+    private const string WORKFLOW_FILE = 'tia-baseline.yml';
+
+    /**
+     * Artifact name the workflow uploads under. The artifact is a zip
+     * containing `graph.json` (always) + `coverage.bin` (optional).
+     */
+    private const string ARTIFACT_NAME = 'pest-tia-baseline';
+
+    /**
+     * Asset filenames inside the artifact — mirror the state keys so the
+     * CI publisher and the sync consumer stay in lock-step.
+     */
+    private const string GRAPH_ASSET = Tia::KEY_GRAPH;
+
+    private const string COVERAGE_ASSET = Tia::KEY_COVERAGE_CACHE;
+
+    /**
+     * Cooldown (in seconds) applied after a failed baseline fetch.
+     * Rationale: when the remote workflow hasn't published yet, every
+     * `pest --tia` invocation would otherwise re-hit `gh run list` and
+     * re-print the publish instructions — noisy + slow. Back off for a
+     * day, let the user override with `--tia-refetch`.
+     */
+    private const int FETCH_COOLDOWN_SECONDS = 86400;
+
+    public function __construct(
+        private State $state,
+        private OutputInterface $output,
+    ) {}
+
+    /**
+     * Detects the repo, fetches the latest baseline artifact, writes its
+     * contents into the TIA state store. Returns true when the graph blob
+     * landed; coverage is best-effort since plain `--tia` (no `--coverage`)
+     * never reads it.
+     *
+     * `$force = true` (driven by `--tia-refetch`) ignores the post-failure
+     * cooldown so the user can retry on demand without waiting out the
+     * 24h window.
+     */
+    public function fetchIfAvailable(string $projectRoot, bool $force = false): bool
+    {
+        $repo = $this->detectGitHubRepo($projectRoot);
+
+        if ($repo === null) {
+            return false;
+        }
+
+        if (! $force && ($remaining = $this->cooldownRemaining()) !== null) {
+            $this->output->writeln(sprintf(
+                '  <fg=yellow>TIA</> last fetch found no baseline — next auto-retry in %s. '
+                    .'Override with <fg=cyan>--tia-refetch</>.',
+                $this->formatDuration($remaining),
+            ));
+
+            return false;
+        }
+
+        $this->output->writeln(sprintf(
+            '  <fg=cyan>TIA</> fetching baseline from <fg=white>%s</>…',
+            $repo,
+        ));
+
+        $payload = $this->download($repo);
+
+        if ($payload === null) {
+            $this->startCooldown();
+            $this->emitPublishInstructions($repo);
+
+            return false;
+        }
+
+        if (! $this->state->write(Tia::KEY_GRAPH, $payload['graph'])) {
+            return false;
+        }
+
+        if ($payload['coverage'] !== null) {
+            $this->state->write(Tia::KEY_COVERAGE_CACHE, $payload['coverage']);
+        }
+
+        // Successful fetch wipes any stale cooldown so the next failure
+        // (say, weeks later) starts a fresh 24h timer rather than inheriting
+        // one from the deep past.
+        $this->clearCooldown();
+
+        $this->output->writeln(sprintf(
+            '  <fg=green>TIA</> baseline ready (%s).',
+            $this->formatSize(strlen($payload['graph']) + strlen($payload['coverage'] ?? '')),
+        ));
+
+        return true;
+    }
+
+    /**
+     * Seconds left on the cooldown, or `null` when the cooldown is cleared
+     * / expired / unreadable.
+     */
+    private function cooldownRemaining(): ?int
+    {
+        $raw = $this->state->read(Tia::KEY_FETCH_COOLDOWN);
+
+        if ($raw === null) {
+            return null;
+        }
+
+        $decoded = json_decode($raw, true);
+
+        if (! is_array($decoded) || ! isset($decoded['until']) || ! is_int($decoded['until'])) {
+            return null;
+        }
+
+        $remaining = $decoded['until'] - time();
+
+        return $remaining > 0 ? $remaining : null;
+    }
+
+    private function startCooldown(): void
+    {
+        $this->state->write(Tia::KEY_FETCH_COOLDOWN, (string) json_encode([
+            'until' => time() + self::FETCH_COOLDOWN_SECONDS,
+        ]));
+    }
+
+    private function clearCooldown(): void
+    {
+        $this->state->delete(Tia::KEY_FETCH_COOLDOWN);
+    }
+
+    private function formatDuration(int $seconds): string
+    {
+        if ($seconds >= 3600) {
+            return (int) round($seconds / 3600).'h';
+        }
+
+        if ($seconds >= 60) {
+            return (int) round($seconds / 60).'m';
+        }
+
+        return $seconds.'s';
+    }
+
+    /**
+     * Prints actionable instructions for publishing a first baseline when
+     * the consumer-side fetch finds nothing.
+     *
+     * Behaviour splits on environment:
+     *   - **CI:** a single line. The current run is almost certainly *the*
+     *     publisher (it's what this workflow does by definition), so
+     *     printing the whole recipe again is redundant and noisy.
+     *   - **Local:** the full recipe, adapted to Laravel's pre-test steps
+     *     (`.env.example` copy + `artisan key:generate`) when the framework
+     *     is present. Generic PHP projects get a slimmer skeleton.
+     */
+    private function emitPublishInstructions(string $repo): void
+    {
+        if ($this->isCi()) {
+            $this->output->writeln(
+                '  <fg=yellow>TIA</> no baseline yet — this run will produce one.',
+            );
+
+            return;
+        }
+
+        $yaml = $this->isLaravel()
+            ? $this->laravelWorkflowYaml()
+            : $this->genericWorkflowYaml();
+
+        $preamble = [
+            '  <fg=yellow>TIA</> no baseline published yet — recording locally.',
+            '',
+            '  To share the baseline with your team, add this workflow to the repo:',
+            '',
+            '    <fg=cyan>.github/workflows/tia-baseline.yml</>',
+            '',
+        ];
+
+        $indentedYaml = array_map(
+            static fn (string $line): string => '      '.$line,
+            explode("\n", $yaml),
+        );
+
+        $trailer = [
+            '',
+            sprintf('  Commit, push, then run once:  <fg=cyan>gh workflow run tia-baseline.yml -R %s</>', $repo),
+            '  Details: <fg=gray>https://pestphp.com/docs/tia/ci</>',
+            '',
+        ];
+
+        $this->output->writeln([...$preamble, ...$indentedYaml, ...$trailer]);
+    }
+
+    /**
+     * True when running inside a CI provider. Conservative list — only the
+     * three providers Pest formally supports / sees in the wild. `CI=true`
+     * alone is ambiguous (users set it locally too) so we require a
+     * provider-specific flag.
+     */
+    private function isCi(): bool
+    {
+        return getenv('GITHUB_ACTIONS') === 'true'
+            || getenv('GITLAB_CI') === 'true'
+            || getenv('CIRCLECI') === 'true';
+    }
+
+    private function isLaravel(): bool
+    {
+        return class_exists(InstalledVersions::class)
+            && InstalledVersions::isInstalled('laravel/framework');
+    }
+
+    /**
+     * Laravel projects need a populated `.env` and a generated `APP_KEY`
+     * before the first boot, otherwise `Illuminate\Encryption\MissingAppKeyException`
+     * fires during `setUp`. Include the standard pre-test dance plus the
+     * extension set typical Laravel apps rely on.
+     */
+    private function laravelWorkflowYaml(): string
+    {
+        return <<<'YAML'
+name: TIA Baseline
+on:
+  push: { branches: [main] }
+  schedule: [{ cron: '0 3 * * *' }]
+  workflow_dispatch:
+jobs:
+  baseline:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
+      - uses: shivammathur/setup-php@v2
+        with:
+          php-version: '8.4'
+          coverage: xdebug
+          extensions: json, dom, curl, libxml, mbstring, zip, pdo, pdo_sqlite, sqlite3, bcmath, intl
+      - run: cp .env.example .env
+      - run: composer install --no-interaction --prefer-dist
+      - run: php artisan key:generate
+      - run: ./vendor/bin/pest --parallel --tia --coverage
+      - name: Stage baseline for upload
+        shell: bash
+        run: |
+          mkdir -p .pest-tia-baseline
+          cp -R "$HOME/.pest/tia"/*/. .pest-tia-baseline/
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pest-tia-baseline
+          path: .pest-tia-baseline/
+          retention-days: 30
+YAML;
+    }
+
+    private function genericWorkflowYaml(): string
+    {
+        return <<<'YAML'
+name: TIA Baseline
+on:
+  push: { branches: [main] }
+  schedule: [{ cron: '0 3 * * *' }]
+  workflow_dispatch:
+jobs:
+  baseline:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
+      - uses: shivammathur/setup-php@v2
+        with: { php-version: '8.4', coverage: xdebug }
+      - run: composer install --no-interaction --prefer-dist
+      - run: ./vendor/bin/pest --parallel --tia --coverage
+      - name: Stage baseline for upload
+        shell: bash
+        run: |
+          mkdir -p .pest-tia-baseline
+          cp -R "$HOME/.pest/tia"/*/. .pest-tia-baseline/
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pest-tia-baseline
+          path: .pest-tia-baseline/
+          retention-days: 30
+YAML;
+    }
+
+    /**
+     * Parses `.git/config` for the `origin` remote and extracts
+     * `org/repo`. Supports the two URL flavours git emits out of the box.
+     * Non-GitHub remotes (GitLab, Bitbucket, self-hosted) → null, which
+     * silently opts the repo out of auto-sync.
+     */
+    private function detectGitHubRepo(string $projectRoot): ?string
+    {
+        $gitConfig = $projectRoot.DIRECTORY_SEPARATOR.'.git'.DIRECTORY_SEPARATOR.'config';
+
+        if (! is_file($gitConfig)) {
+            return null;
+        }
+
+        $content = @file_get_contents($gitConfig);
+
+        if ($content === false) {
+            return null;
+        }
+
+        // Find the `[remote "origin"]` section and the first `url` line
+        // inside it. Tolerates INI whitespace quirks (tabs, CRLF).
+        if (preg_match('/\[remote "origin"\][^\[]*?url\s*=\s*(\S+)/s', $content, $match) !== 1) {
+            return null;
+        }
+
+        $url = $match[1];
+
+        // SSH: git@github.com:org/repo(.git)
+        if (preg_match('#^git@github\.com:([\w.-]+/[\w.-]+?)(?:\.git)?$#', $url, $m) === 1) {
+            return $m[1];
+        }
+
+        // HTTPS: https://github.com/org/repo(.git) (optional trailing slash)
+        if (preg_match('#^https?://github\.com/([\w.-]+/[\w.-]+?)(?:\.git)?/?$#', $url, $m) === 1) {
+            return $m[1];
+        }
+
+        return null;
+    }
+
+    /**
+     * Two-step fetch: find the latest successful run of the baseline
+     * workflow, then download the named artifact from it. Returns
+     * `['graph' => bytes, 'coverage' => bytes|null]` on success, or null
+     * if `gh` is unavailable, the workflow hasn't run yet, the artifact
+     * is missing, or any shell step fails.
+     *
+     * @return array{graph: string, coverage: ?string}|null
+     */
+    private function download(string $repo): ?array
+    {
+        if (! $this->commandExists('gh')) {
+            return null;
+        }
+
+        $runId = $this->latestSuccessfulRunId($repo);
+
+        if ($runId === null) {
+            return null;
+        }
+
+        $tmpDir = sys_get_temp_dir().DIRECTORY_SEPARATOR.'pest-tia-'.bin2hex(random_bytes(4));
+
+        if (! @mkdir($tmpDir, 0755, true) && ! is_dir($tmpDir)) {
+            return null;
+        }
+
+        $process = new Process([
+            'gh', 'run', 'download', $runId,
+            '-R', $repo,
+            '-n', self::ARTIFACT_NAME,
+            '-D', $tmpDir,
+        ]);
+        $process->setTimeout(120.0);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            $this->cleanup($tmpDir);
+
+            return null;
+        }
+
+        $graphPath = $tmpDir.DIRECTORY_SEPARATOR.self::GRAPH_ASSET;
+        $coveragePath = $tmpDir.DIRECTORY_SEPARATOR.self::COVERAGE_ASSET;
+
+        $graph = is_file($graphPath) ? @file_get_contents($graphPath) : false;
+
+        if ($graph === false) {
+            $this->cleanup($tmpDir);
+
+            return null;
+        }
+
+        $coverage = is_file($coveragePath) ? @file_get_contents($coveragePath) : false;
+
+        $this->cleanup($tmpDir);
+
+        return [
+            'graph' => $graph,
+            'coverage' => $coverage === false ? null : $coverage,
+        ];
+    }
+
+    /**
+     * Queries GitHub for the most recent successful run of the baseline
+     * workflow. `--jq '.[0].databaseId // empty'` coerces "no runs found"
+     * into an empty string, which we map to null.
+     */
+    private function latestSuccessfulRunId(string $repo): ?string
+    {
+        $process = new Process([
+            'gh', 'run', 'list',
+            '-R', $repo,
+            '--workflow', self::WORKFLOW_FILE,
+            '--status', 'success',
+            '--limit', '1',
+            '--json', 'databaseId',
+            '--jq', '.[0].databaseId // empty',
+        ]);
+        $process->setTimeout(30.0);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        $runId = trim($process->getOutput());
+
+        return $runId === '' ? null : $runId;
+    }
+
+    private function commandExists(string $cmd): bool
+    {
+        $probe = new Process(['command', '-v', $cmd]);
+        $probe->run();
+
+        if ($probe->isSuccessful()) {
+            return true;
+        }
+
+        $which = new Process(['which', $cmd]);
+        $which->run();
+
+        return $which->isSuccessful();
+    }
+
+    private function cleanup(string $dir): void
+    {
+        if (! is_dir($dir)) {
+            return;
+        }
+
+        $entries = glob($dir.DIRECTORY_SEPARATOR.'*');
+
+        if ($entries !== false) {
+            foreach ($entries as $entry) {
+                if (is_file($entry)) {
+                    @unlink($entry);
+                }
+            }
+        }
+
+        @rmdir($dir);
+    }
+
+    private function formatSize(int $bytes): string
+    {
+        if ($bytes >= 1024 * 1024) {
+            return sprintf('%.1f MB', $bytes / 1024 / 1024);
+        }
+
+        if ($bytes >= 1024) {
+            return sprintf('%.1f KB', $bytes / 1024);
+        }
+
+        return $bytes.' B';
+    }
+}

src/Plugins/Tia/Bootstrapper.php

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Contracts\Bootstrapper as BootstrapperContract;
+use Pest\Plugins\Tia\Contracts\State;
+use Pest\Support\Container;
+use Pest\TestSuite;
+
+/**
+ * Plugin-level container registrations for TIA. Runs as part of Kernel's
+ * bootstrapper chain so Tia's own service graph is set up without Kernel
+ * having to know about any of its internals.
+ *
+ * Most Tia services (`Recorder`, `CoverageCollector`, `WatchPatterns`,
+ * `ResultCollector`, `BaselineSync`) are auto-buildable — Pest's container
+ * resolves them lazily via constructor reflection. The only service that
+ * requires an explicit binding is the `State` contract, because the
+ * filesystem implementation needs a root-directory string that reflection
+ * can't infer.
+ *
+ * @internal
+ */
+final readonly class Bootstrapper implements BootstrapperContract
+{
+    public function __construct(private Container $container) {}
+
+    public function boot(): void
+    {
+        $this->container->add(State::class, new FileState($this->tempDir()));
+    }
+
+    /**
+     * TIA's per-project state directory. Default layout is
+     * `~/.pest/tia/<project-key>/` so the graph survives `composer
+     * install`, stays out of the project tree, and is naturally shared
+     * across worktrees of the same repo. See {@see Storage} for the key
+     * derivation and the home-dir-missing fallback.
+     */
+    private function tempDir(): string
+    {
+        $testSuite = $this->container->get(TestSuite::class);
+        assert($testSuite instanceof TestSuite);
+
+        return Storage::tempDir($testSuite->rootPath);
+    }
+}

src/Plugins/Tia/CachedTestResult.php

@@ -1,33 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\Plugins\Tia;
-
-/**
- * Immutable snapshot of a previous test run's outcome. Stored in the TIA
- * graph and returned by `BeforeEachable::beforeEach` so `Testable` can
- * faithfully replay the exact status — pass, fail, skip, todo, incomplete,
- * risky, etc. — without executing the test body.
- *
- * @internal
- */
-final readonly class CachedTestResult
-{
-    /**
-     * PHPUnit TestStatus int constants:
-     *   0 = success, 1 = skipped, 2 = incomplete,
-     *   3 = notice, 4 = deprecation, 5 = risky,
-     *   6 = warning, 7 = failure, 8 = error.
-     */
-    public function __construct(
-        public int $status,
-        public string $message = '',
-        public float $time = 0.0,
-    ) {}
-
-    public function isSuccess(): bool
-    {
-        return $this->status === 0;
-    }
-}

src/Plugins/Tia/ChangedFiles.php

@@ -48,27 +48,46 @@ final readonly class ChangedFiles
             return $files;
         }
 
+        // Union: `$files` (what git currently reports) + every path that was
+        // dirty last run. The second set matters for reverts — when a user
+        // undoes a local edit, the file matches HEAD again and git reports
+        // it clean, so it would never enter `$files`. But it has genuinely
+        // changed vs the snapshot we captured during the bad run, so it
+        // must be checked.
+        $candidates = array_fill_keys($files, true);
+
+        foreach (array_keys($lastRunTree) as $snapshotted) {
+            $candidates[$snapshotted] = true;
+        }
+
         $remaining = [];
 
-        foreach ($files as $file) {
-            if (! isset($lastRunTree[$file])) {
+        foreach (array_keys($candidates) as $file) {
+            $snapshot = $lastRunTree[$file] ?? null;
+            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
+            $exists = is_file($absolute);
+
+            if ($snapshot === null) {
+                // File wasn't in last-run tree at all — trust git's signal.
                 $remaining[] = $file;
 
                 continue;
             }
 
-            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
-
-            if (! is_file($absolute)) {
-                // File deleted since last run — definitely changed.
+            if (! $exists) {
+                // Missing now. If the snapshot recorded it as absent too
+                // (sentinel ''), state is identical to last run — unchanged.
+                // Otherwise it was present last run and got deleted since.
+                if ($snapshot !== '') {
                     $remaining[] = $file;
+                }
 
                 continue;
             }
 
             $hash = @hash_file('xxh128', $absolute);
 
-            if ($hash === false || $hash !== $lastRunTree[$file]) {
+            if ($hash === false || $hash !== $snapshot) {
                 $remaining[] = $file;
             }
         }
@@ -92,6 +111,11 @@ final readonly class ChangedFiles
             $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
 
             if (! is_file($absolute)) {
+                // Record the deletion with an empty-string sentinel so the
+                // next run recognises "still deleted" as unchanged rather
+                // than re-flagging the file as a fresh change.
+                $out[$file] = '';
+
                 continue;
             }
 

src/Plugins/Tia/Contracts/State.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\Contracts;
+
+/**
+ * Storage contract for TIA's persistent state (graph, baselines, affected
+ * set, worker partials, coverage snapshots). Modelled as a flat key/value
+ * store of raw byte blobs so implementations can sit on top of whatever
+ * backend fits — a directory, a shared cache, a remote object store — and
+ * TIA's logic stays identical.
+ *
+ * @internal
+ */
+interface State
+{
+    /**
+     * Returns the stored blob for `$key`, or `null` when the key is unset
+     * or cannot be read.
+     */
+    public function read(string $key): ?string;
+
+    /**
+     * Atomically stores `$content` under `$key`. Existing value (if any) is
+     * replaced. Implementations SHOULD guarantee that concurrent readers
+     * never observe partial writes.
+     */
+    public function write(string $key, string $content): bool;
+
+    /**
+     * Removes `$key`. Returns true whether or not the key existed beforehand
+     * — callers should treat a `true` result as "the key is now absent",
+     * not "the key was present and has been removed."
+     */
+    public function delete(string $key): bool;
+
+    public function exists(string $key): bool;
+
+    /**
+     * Returns every key whose name starts with `$prefix`. Used to collect
+     * paratest worker partials (`worker-edges-<token>.json`, etc.) without
+     * exposing backend-specific glob semantics.
+     *
+     * @return list<string>
+     */
+    public function keysWithPrefix(string $prefix): array;
+}

src/Plugins/Tia/CoverageCollector.php

@@ -0,0 +1,152 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use PHPUnit\Runner\CodeCoverage as PhpUnitCodeCoverage;
+use ReflectionClass;
+use Throwable;
+
+/**
+ * Extracts per-test file coverage from PHPUnit's shared `CodeCoverage`
+ * instance. Used when TIA piggybacks on `--coverage` instead of starting
+ * its own driver session — both share the same PCOV / Xdebug state, so
+ * running two recorders in parallel would corrupt each other's data.
+ *
+ * PHPUnit tags every coverage sample with the current test's id
+ * (`$test->valueObjectForEvents()->id()`, e.g. `Foo\BarTest::baz`). The
+ * per-file / per-line coverage map therefore already carries everything
+ * we need to rebuild TIA edges at the end of the run.
+ *
+ * @internal
+ */
+final class CoverageCollector
+{
+    /**
+     * Cached `className → test file` lookups. Class reflection is cheap
+     * individually but the record run can visit tens of thousands of
+     * samples, so the cache matters.
+     *
+     * @var array<string, string|null>
+     */
+    private array $classFileCache = [];
+
+    /**
+     * Rebuilds the same `absolute test file → list<absolute source file>`
+     * shape that `Recorder::perTestFiles()` exposes, so callers can treat
+     * the two collectors interchangeably when feeding the graph.
+     *
+     * @return array<string, array<int, string>>
+     */
+    public function perTestFiles(): array
+    {
+        if (! PhpUnitCodeCoverage::instance()->isActive()) {
+            return [];
+        }
+
+        try {
+            $lineCoverage = PhpUnitCodeCoverage::instance()
+                ->codeCoverage()
+                ->getData()
+                ->lineCoverage();
+        } catch (Throwable) {
+            return [];
+        }
+
+        /** @var array<string, array<string, true>> $edges */
+        $edges = [];
+
+        foreach ($lineCoverage as $sourceFile => $lines) {
+            // Collect the set of tests that hit any line in this file once,
+            // then emit one edge per (testFile, sourceFile) pair. Walking
+            // the lines per test would re-resolve the test file repeatedly.
+            $testIds = [];
+
+            foreach ($lines as $hits) {
+                if ($hits === null) {
+                    continue;
+                }
+
+                foreach ($hits as $id) {
+                    $testIds[$id] = true;
+                }
+            }
+
+            foreach (array_keys($testIds) as $testId) {
+                $testFile = $this->testIdToFile($testId);
+
+                if ($testFile === null) {
+                    continue;
+                }
+
+                $edges[$testFile][$sourceFile] = true;
+            }
+        }
+
+        $out = [];
+
+        foreach ($edges as $testFile => $sources) {
+            $out[$testFile] = array_keys($sources);
+        }
+
+        return $out;
+    }
+
+    public function reset(): void
+    {
+        $this->classFileCache = [];
+    }
+
+    private function testIdToFile(string $testId): ?string
+    {
+        // PHPUnit's test id is `ClassName::methodName` with an optional
+        // `#dataSetName` suffix for data-provider runs. Strip the dataset
+        // part — we only need the class.
+        $hash = strpos($testId, '#');
+        $identifier = $hash === false ? $testId : substr($testId, 0, $hash);
+
+        if (! str_contains($identifier, '::')) {
+            return null;
+        }
+
+        [$className] = explode('::', $identifier, 2);
+
+        if (array_key_exists($className, $this->classFileCache)) {
+            return $this->classFileCache[$className];
+        }
+
+        $file = $this->resolveClassFile($className);
+        $this->classFileCache[$className] = $file;
+
+        return $file;
+    }
+
+    private function resolveClassFile(string $className): ?string
+    {
+        if (! class_exists($className, false)) {
+            return null;
+        }
+
+        $reflection = new ReflectionClass($className);
+
+        // Pest's eval'd test classes expose the original `.php` path on a
+        // static `$__filename`. The eval'd class itself has no file of its
+        // own, so prefer this property when present.
+        if ($reflection->hasProperty('__filename')) {
+            $property = $reflection->getProperty('__filename');
+
+            if ($property->isStatic()) {
+                $value = $property->getValue();
+
+                if (is_string($value)) {
+                    return $value;
+                }
+            }
+        }
+
+        $file = $reflection->getFileName();
+
+        return is_string($file) ? $file : null;
+    }
+}

src/Plugins/Tia/CoverageMerger.php

@@ -0,0 +1,187 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Plugins\Tia;
+use Pest\Plugins\Tia\Contracts\State;
+use Pest\Support\Container;
+use SebastianBergmann\CodeCoverage\CodeCoverage;
+use Throwable;
+
+/**
+ * Merges the current run's PHPUnit coverage into a cached full-suite
+ * snapshot so `--tia --coverage` can produce a complete report after
+ * executing only the affected tests.
+ *
+ * Invoked from `Pest\Support\Coverage::report()` right before the coverage
+ * file is consumed. A marker dropped by the `Tia` plugin gates the
+ * behaviour — plain `--coverage` runs (no `--tia`) leave the marker absent
+ * and therefore keep their existing semantics.
+ *
+ * Algorithm
+ * ---------
+ * The PHPUnit coverage PHP file unserialises to a `CodeCoverage` object.
+ * Its `ProcessedCodeCoverageData` stores, per source file, per line, the
+ * list of test IDs that covered that line. We:
+ *
+ *   1. Load the cached snapshot from `State` (serialised bytes).
+ *   2. Strip every test id that re-ran this time from the cached map —
+ *      the tests that ran now are the ones whose attribution is fresh.
+ *   3. Merge the current run into the stripped cached snapshot via
+ *      `CodeCoverage::merge()`.
+ *   4. Write the merged result back to the report path (so Pest's report
+ *      generator sees the full suite) and back into `State` (for the
+ *      next invocation).
+ *
+ * If no cache exists yet (first `--tia --coverage` run on this machine)
+ * we serialise the current object and save it — nothing to merge yet.
+ *
+ * @internal
+ */
+final class CoverageMerger
+{
+    public static function applyIfMarked(string $reportPath): void
+    {
+        $state = self::state();
+
+        if (! $state instanceof State || ! $state->exists(Tia::KEY_COVERAGE_MARKER)) {
+            return;
+        }
+
+        $state->delete(Tia::KEY_COVERAGE_MARKER);
+
+        $cachedBytes = $state->read(Tia::KEY_COVERAGE_CACHE);
+
+        if ($cachedBytes === null) {
+            // First `--tia --coverage` run: nothing cached yet, so the
+            // current file already represents the full suite. Capture it
+            // verbatim (as serialised bytes) for next time.
+            $current = self::requireCoverage($reportPath);
+
+            if ($current instanceof CodeCoverage) {
+                $state->write(Tia::KEY_COVERAGE_CACHE, serialize($current));
+            }
+
+            return;
+        }
+
+        $cached = self::unserializeCoverage($cachedBytes);
+        $current = self::requireCoverage($reportPath);
+
+        if (! $cached instanceof CodeCoverage || ! $current instanceof CodeCoverage) {
+            return;
+        }
+
+        self::stripCurrentTestsFromCached($cached, $current);
+
+        $cached->merge($current);
+
+        $serialised = serialize($cached);
+
+        // Write back to the PHPUnit-style `.cov` path so the report reader
+        // can `require` it, and to the state cache for the next run.
+        @file_put_contents(
+            $reportPath,
+            '<?php return unserialize('.var_export($serialised, true).");\n",
+        );
+        $state->write(Tia::KEY_COVERAGE_CACHE, $serialised);
+    }
+
+    /**
+     * Removes from `$cached`'s per-line test attribution any test id that
+     * appears in `$current`. Those tests just ran, so the fresh slice is
+     * authoritative — keeping stale attribution in the cache would claim
+     * a test still covers a line it no longer touches.
+     */
+    private static function stripCurrentTestsFromCached(CodeCoverage $cached, CodeCoverage $current): void
+    {
+        $currentIds = self::collectTestIds($current);
+
+        if ($currentIds === []) {
+            return;
+        }
+
+        $cachedData = $cached->getData();
+        $lineCoverage = $cachedData->lineCoverage();
+
+        foreach ($lineCoverage as $file => $lines) {
+            foreach ($lines as $line => $ids) {
+                if ($ids === null) {
+                    continue;
+                }
+                if ($ids === []) {
+                    continue;
+                }
+                $filtered = array_values(array_diff($ids, $currentIds));
+
+                if ($filtered !== $ids) {
+                    $lineCoverage[$file][$line] = $filtered;
+                }
+            }
+        }
+
+        $cachedData->setLineCoverage($lineCoverage);
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private static function collectTestIds(CodeCoverage $coverage): array
+    {
+        $ids = [];
+
+        foreach ($coverage->getData()->lineCoverage() as $lines) {
+            foreach ($lines as $hits) {
+                if ($hits === null) {
+                    continue;
+                }
+
+                foreach ($hits as $id) {
+                    $ids[$id] = true;
+                }
+            }
+        }
+
+        return array_keys($ids);
+    }
+
+    private static function state(): ?State
+    {
+        try {
+            $state = Container::getInstance()->get(State::class);
+        } catch (Throwable) {
+            return null;
+        }
+
+        return $state instanceof State ? $state : null;
+    }
+
+    private static function requireCoverage(string $reportPath): ?CodeCoverage
+    {
+        if (! is_file($reportPath)) {
+            return null;
+        }
+
+        try {
+            /** @var mixed $value */
+            $value = require $reportPath;
+        } catch (Throwable) {
+            return null;
+        }
+
+        return $value instanceof CodeCoverage ? $value : null;
+    }
+
+    private static function unserializeCoverage(string $bytes): ?CodeCoverage
+    {
+        try {
+            $value = @unserialize($bytes);
+        } catch (Throwable) {
+            return null;
+        }
+
+        return $value instanceof CodeCoverage ? $value : null;
+    }
+}

src/Plugins/Tia/FileState.php

@@ -0,0 +1,150 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Plugins\Tia\Contracts\State;
+
+/**
+ * Filesystem-backed implementation of the TIA `State` contract. Each key
+ * maps verbatim to a file name under `$rootDir`, so existing `.temp/*.json`
+ * layouts are preserved exactly.
+ *
+ * The root directory is created lazily on first write — callers don't have
+ * to pre-provision it, and reads against a missing directory simply return
+ * `null` rather than throwing.
+ *
+ * @internal
+ */
+final readonly class FileState implements State
+{
+    /**
+     * Configured root. May not exist on disk yet; resolved + created on
+     * the first write. Keeping the raw string lets the instance be built
+     * before Pest's temp dir has been materialised.
+     */
+    private string $rootDir;
+
+    public function __construct(string $rootDir)
+    {
+        $this->rootDir = rtrim($rootDir, DIRECTORY_SEPARATOR);
+    }
+
+    public function read(string $key): ?string
+    {
+        $path = $this->pathFor($key);
+
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $bytes = @file_get_contents($path);
+
+        return $bytes === false ? null : $bytes;
+    }
+
+    public function write(string $key, string $content): bool
+    {
+        if (! $this->ensureRoot()) {
+            return false;
+        }
+
+        $path = $this->pathFor($key);
+        $tmp = $path.'.'.bin2hex(random_bytes(4)).'.tmp';
+
+        if (@file_put_contents($tmp, $content) === false) {
+            return false;
+        }
+
+        // Atomic rename — on POSIX filesystems this is a single-step
+        // replacement, so concurrent readers never see a half-written file.
+        if (! @rename($tmp, $path)) {
+            @unlink($tmp);
+
+            return false;
+        }
+
+        return true;
+    }
+
+    public function delete(string $key): bool
+    {
+        $path = $this->pathFor($key);
+
+        if (! is_file($path)) {
+            return true;
+        }
+
+        return @unlink($path);
+    }
+
+    public function exists(string $key): bool
+    {
+        return is_file($this->pathFor($key));
+    }
+
+    public function keysWithPrefix(string $prefix): array
+    {
+        $root = $this->resolvedRoot();
+
+        if ($root === null) {
+            return [];
+        }
+
+        $pattern = $root.DIRECTORY_SEPARATOR.$prefix.'*';
+        $matches = glob($pattern);
+
+        if ($matches === false) {
+            return [];
+        }
+
+        $keys = [];
+
+        foreach ($matches as $path) {
+            $keys[] = basename($path);
+        }
+
+        return $keys;
+    }
+
+    /**
+     * Absolute path for `$key`. Not part of the interface — used by the
+     * coverage merger and similar callers that need direct filesystem
+     * access (e.g. `require` on a cached PHP file). Consumers that only
+     * deal in bytes should go through `read()` / `write()`.
+     */
+    public function pathFor(string $key): string
+    {
+        return $this->rootDir.DIRECTORY_SEPARATOR.$key;
+    }
+
+    /**
+     * Returns the resolved root if it exists already, otherwise `null`.
+     * Used by read-side helpers so they don't eagerly create the directory
+     * just to find nothing inside.
+     */
+    private function resolvedRoot(): ?string
+    {
+        $resolved = @realpath($this->rootDir);
+
+        return $resolved === false ? null : $resolved;
+    }
+
+    /**
+     * Creates the root dir on demand. Returns false only when creation
+     * fails and the directory still isn't there afterwards.
+     */
+    private function ensureRoot(): bool
+    {
+        if (is_dir($this->rootDir)) {
+            return true;
+        }
+
+        if (@mkdir($this->rootDir, 0755, true)) {
+            return true;
+        }
+
+        return is_dir($this->rootDir);
+    }
+}

src/Plugins/Tia/Fingerprint.php

@@ -5,52 +5,161 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia;
 
 /**
- * Captures environmental inputs that, when changed, make the TIA graph stale.
+ * Captures environmental inputs that, when changed, may make the TIA graph
+ * or its recorded results stale. The fingerprint is split into two buckets:
  *
- * Any drift in PHP version, Composer lock, or Pest/PHPUnit config can change
- * what a test actually exercises, so the graph must be rebuilt in those cases.
+ *   - **structural** — describes what the graph's *edges* were recorded
+ *     against. If any of these drift (`composer.lock`, `tests/Pest.php`,
+ *     Pest's factory codegen, etc.) the edges themselves are potentially
+ *     wrong and the graph must rebuild from scratch.
+ *   - **environmental** — describes the *runtime* the results were captured
+ *     on (PHP minor, extension set, Pest version). Drift here means the
+ *     edges are still trustworthy, but the cached per-test results (pass/
+ *     fail/time) may not reproduce on this machine. Tia's handler drops the
+ *     branch's results + coverage cache and re-runs to freshen them, rather
+ *     than re-recording from scratch.
+ *
+ * Legacy flat-shape graphs (schema ≤ 3) are read as structurally stale and
+ * rebuilt on first load; the schema bump in the structural bucket takes
+ * care of that automatically.
  *
  * @internal
  */
 final readonly class Fingerprint
 {
-    // Bump this whenever the set of inputs or the hash algorithm changes, so
-    // older graphs are invalidated automatically.
-    private const int SCHEMA_VERSION = 2;
+    // Bump this whenever the set of inputs or the hash algorithm changes,
+    // so older graphs are invalidated automatically.
+    private const int SCHEMA_VERSION = 4;
 
     /**
-     * @return array<string, int|string|null>
+     * @return array{
+     *     structural: array<string, int|string|null>,
+     *     environmental: array<string, string|null>,
+     * }
      */
     public static function compute(string $projectRoot): array
     {
         return [
+            'structural' => [
                 'schema' => self::SCHEMA_VERSION,
-            'php' => PHP_VERSION,
-            'pest' => self::readPestVersion($projectRoot),
                 'composer_lock' => self::hashIfExists($projectRoot.'/composer.lock'),
                 'phpunit_xml' => self::hashIfExists($projectRoot.'/phpunit.xml'),
                 'phpunit_xml_dist' => self::hashIfExists($projectRoot.'/phpunit.xml.dist'),
                 'pest_php' => self::hashIfExists($projectRoot.'/tests/Pest.php'),
-            // Pest's generated classes bake the code-generation logic in — if
-            // TestCaseFactory changes (new attribute, different method
-            // signature, etc.) every previously-recorded edge is stale.
-            // Hashing the factory sources makes path-repo / dev-main installs
-            // automatically rebuild their graphs when Pest itself is edited.
+                // Pest's generated classes bake the code-generation logic
+                // in — if TestCaseFactory changes (new attribute, different
+                // method signature, etc.) every previously-recorded edge is
+                // stale. Hashing the factory sources makes path-repo /
+                // dev-main installs automatically rebuild their graphs when
+                // Pest itself is edited.
                 'pest_factory' => self::hashIfExists(__DIR__.'/../../Factories/TestCaseFactory.php'),
                 'pest_method_factory' => self::hashIfExists(__DIR__.'/../../Factories/TestCaseMethodFactory.php'),
+            ],
+            'environmental' => [
+                // PHP **minor** only (8.4, not 8.4.19) — CI's resolved patch
+                // almost never matches a dev's Herd/Homebrew install, and
+                // the patch rarely changes anything test-visible.
+                'php_minor' => PHP_MAJOR_VERSION.'.'.PHP_MINOR_VERSION,
+                'extensions' => self::extensionsFingerprint($projectRoot),
+                'pest' => self::readPestVersion($projectRoot),
+            ],
         ];
     }
 
     /**
+     * True when the structural buckets match. Drift here means the edges
+     * are potentially wrong; caller should discard the graph and rebuild.
+     *
      * @param  array<string, mixed>  $a
      * @param  array<string, mixed>  $b
      */
-    public static function matches(array $a, array $b): bool
+    public static function structuralMatches(array $a, array $b): bool
     {
-        ksort($a);
-        ksort($b);
+        $aStructural = self::structuralOnly($a);
+        $bStructural = self::structuralOnly($b);
 
-        return $a === $b;
+        ksort($aStructural);
+        ksort($bStructural);
+
+        return $aStructural === $bStructural;
+    }
+
+    /**
+     * Returns a list of field names that drifted between the stored and
+     * current environmental fingerprints. Empty list = no drift. Caller
+     * uses this to print a human-readable warning and to decide whether
+     * per-test results should be dropped (any drift → yes).
+     *
+     * @param  array<string, mixed>  $stored
+     * @param  array<string, mixed>  $current
+     * @return list<string>
+     */
+    public static function environmentalDrift(array $stored, array $current): array
+    {
+        $a = self::environmentalOnly($stored);
+        $b = self::environmentalOnly($current);
+
+        $drifts = [];
+
+        foreach ($a as $key => $value) {
+            if (($b[$key] ?? null) !== $value) {
+                $drifts[] = $key;
+            }
+        }
+
+        foreach ($b as $key => $value) {
+            if (! array_key_exists($key, $a) && $value !== null) {
+                $drifts[] = $key;
+            }
+        }
+
+        return array_values(array_unique($drifts));
+    }
+
+    /**
+     * @param  array<string, mixed>  $fingerprint
+     * @return array<string, mixed>
+     */
+    private static function structuralOnly(array $fingerprint): array
+    {
+        return self::bucket($fingerprint, 'structural');
+    }
+
+    /**
+     * @param  array<string, mixed>  $fingerprint
+     * @return array<string, mixed>
+     */
+    private static function environmentalOnly(array $fingerprint): array
+    {
+        return self::bucket($fingerprint, 'environmental');
+    }
+
+    /**
+     * Returns `$fingerprint[$key]` as an `array<string, mixed>` if it exists
+     * and is an array, otherwise empty. Legacy flat-shape fingerprints
+     * (schema ≤ 3) return empty here, which makes `structuralMatches` fail
+     * and the caller rebuild — the clean migration path.
+     *
+     * @param  array<string, mixed>  $fingerprint
+     * @return array<string, mixed>
+     */
+    private static function bucket(array $fingerprint, string $key): array
+    {
+        $raw = $fingerprint[$key] ?? null;
+
+        if (! is_array($raw)) {
+            return [];
+        }
+
+        $normalised = [];
+
+        foreach ($raw as $k => $v) {
+            if (is_string($k)) {
+                $normalised[$k] = $v;
+            }
+        }
+
+        return $normalised;
     }
 
     private static function hashIfExists(string $path): ?string
@@ -64,6 +173,84 @@ final readonly class Fingerprint
         return $hash === false ? null : $hash;
     }
 
+    /**
+     * Deterministic hash of the extensions the project actually depends on —
+     * the `ext-*` entries in composer.json's `require` / `require-dev`. An
+     * incidental extension loaded on the developer's machine (or on CI) but
+     * not declared as a dependency can't affect correctness of the test
+     * suite, so we ignore it here to keep the drift signal quiet.
+     *
+     * Declared extensions that aren't currently loaded record as `missing`,
+     * which is itself a drift signal worth surfacing.
+     */
+    private static function extensionsFingerprint(string $projectRoot): string
+    {
+        $extensions = self::declaredExtensions($projectRoot);
+
+        if ($extensions === []) {
+            return hash('xxh128', '');
+        }
+
+        sort($extensions);
+
+        $parts = [];
+
+        foreach ($extensions as $name) {
+            $version = phpversion($name);
+            $parts[] = $name.'@'.($version === false ? 'missing' : $version);
+        }
+
+        return hash('xxh128', implode("\n", $parts));
+    }
+
+    /**
+     * Extension names (without the `ext-` prefix) that appear as keys under
+     * `require` or `require-dev` in the project's composer.json. Returns
+     * an empty list when composer.json is missing / unreadable / malformed,
+     * so the environmental fingerprint stays stable in those cases rather
+     * than flapping.
+     *
+     * @return list<string>
+     */
+    private static function declaredExtensions(string $projectRoot): array
+    {
+        $path = $projectRoot.'/composer.json';
+
+        if (! is_file($path)) {
+            return [];
+        }
+
+        $raw = @file_get_contents($path);
+
+        if ($raw === false) {
+            return [];
+        }
+
+        $data = json_decode($raw, true);
+
+        if (! is_array($data)) {
+            return [];
+        }
+
+        $extensions = [];
+
+        foreach (['require', 'require-dev'] as $section) {
+            $packages = $data[$section] ?? null;
+
+            if (! is_array($packages)) {
+                continue;
+            }
+
+            foreach (array_keys($packages) as $package) {
+                if (is_string($package) && str_starts_with($package, 'ext-')) {
+                    $extensions[] = substr($package, 4);
+                }
+            }
+        }
+
+        return array_values(array_unique($extensions));
+    }
+
     private static function readPestVersion(string $projectRoot): string
     {
         $installed = $projectRoot.'/vendor/composer/installed.json';

src/Plugins/Tia/Graph.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest\Plugins\Tia;
 
 use Pest\Support\Container;
+use PHPUnit\Framework\TestStatus\TestStatus;
 
 /**
  * File-level Test Impact Analysis graph.
@@ -59,7 +60,7 @@ final class Graph
      * @var array<string, array{
      *     sha: ?string,
      *     tree: array<string, string>,
-     *     results: array<string, array{status: int, message: string, time: float}>
+     *     results: array<string, array{status: int, message: string, time: float, assertions?: int}>
      * }>
      */
     private array $baselines = [];
@@ -222,7 +223,7 @@ final class Graph
     }
 
     /**
-     * @param  array<string, int|string|null>  $fingerprint
+     * @param  array<string, mixed>  $fingerprint
      */
     public function setFingerprint(array $fingerprint): void
     {
@@ -230,7 +231,7 @@ final class Graph
     }
 
     /**
-     * @return array<string, int|string|null>
+     * @return array<string, mixed>
      */
     public function fingerprint(): array
     {
@@ -256,15 +257,35 @@ final class Graph
         $this->baselines[$branch]['sha'] = $sha;
     }
 
-    public function setResult(string $branch, string $testId, int $status, string $message, float $time): void
+    public function setResult(string $branch, string $testId, int $status, string $message, float $time, int $assertions = 0): void
     {
         $this->ensureBaseline($branch);
         $this->baselines[$branch]['results'][$testId] = [
-            'status' => $status, 'message' => $message, 'time' => $time,
+            'status' => $status,
+            'message' => $message,
+            'time' => $time,
+            'assertions' => $assertions,
         ];
     }
 
-    public function getResult(string $branch, string $testId, string $fallbackBranch = 'main'): ?CachedTestResult
+    /**
+     * Returns the cached assertion count for a test, or `null` if unknown.
+     * Callers use this to feed `addToAssertionCount()` at replay time so
+     * the "Tests: N passed (M assertions)" banner matches the recorded run
+     * instead of defaulting to 1 assertion per test.
+     */
+    public function getAssertions(string $branch, string $testId, string $fallbackBranch = 'main'): ?int
+    {
+        $baseline = $this->baselineFor($branch, $fallbackBranch);
+
+        if (! isset($baseline['results'][$testId]['assertions'])) {
+            return null;
+        }
+
+        return $baseline['results'][$testId]['assertions'];
+    }
+
+    public function getResult(string $branch, string $testId, string $fallbackBranch = 'main'): ?TestStatus
     {
         $baseline = $this->baselineFor($branch, $fallbackBranch);
 
@@ -274,7 +295,21 @@ final class Graph
 
         $r = $baseline['results'][$testId];
 
-        return new CachedTestResult($r['status'], $r['message'], $r['time']);
+        // PHPUnit's `TestStatus::from(int)` ignores messages, so reconstruct
+        // each variant via its specific factory. Keeps the stored message
+        // intact (important for skips/failures shown to the user).
+        return match ($r['status']) {
+            0 => TestStatus::success(),
+            1 => TestStatus::skipped($r['message']),
+            2 => TestStatus::incomplete($r['message']),
+            3 => TestStatus::notice($r['message']),
+            4 => TestStatus::deprecation($r['message']),
+            5 => TestStatus::risky($r['message']),
+            6 => TestStatus::warning($r['message']),
+            7 => TestStatus::failure($r['message']),
+            8 => TestStatus::error($r['message']),
+            default => TestStatus::unknown(),
+        };
     }
 
     /**
@@ -286,6 +321,20 @@ final class Graph
         $this->baselines[$branch]['tree'] = $tree;
     }
 
+    /**
+     * Wipes cached per-test results for the given branch. Edges and tree
+     * snapshot stay intact — the graph still describes the code correctly,
+     * only the "what happened last time" data is reset. Used on
+     * environmental fingerprint drift: the edges were recorded elsewhere
+     * (e.g. CI) so they're still valid, but the results aren't trustworthy
+     * on this machine until the tests re-run here.
+     */
+    public function clearResults(string $branch): void
+    {
+        $this->ensureBaseline($branch);
+        $this->baselines[$branch]['results'] = [];
+    }
+
     /**
      * @return array<string, string>
      */
@@ -295,7 +344,7 @@ final class Graph
     }
 
     /**
-     * @return array{sha: ?string, tree: array<string, string>, results: array<string, array{status: int, message: string, time: float}>}
+     * @return array{sha: ?string, tree: array<string, string>, results: array<string, array{status: int, message: string, time: float, assertions?: int}>}
      */
     private function baselineFor(string $branch, string $fallbackBranch): array
     {
@@ -359,19 +408,15 @@ final class Graph
         }
     }
 
-    public static function load(string $projectRoot, string $path): ?self
+    /**
+     * Rebuilds a graph from its JSON representation. Returns `null` when
+     * the payload is missing, unreadable, or schema-incompatible. Separated
+     * from transport (state backend, file, etc.) so tests can feed bytes
+     * directly without touching disk.
+     */
+    public static function decode(string $json, string $projectRoot): ?self
     {
-        if (! is_file($path)) {
-            return null;
-        }
-
-        $raw = @file_get_contents($path);
-
-        if ($raw === false) {
-            return null;
-        }
-
-        $data = json_decode($raw, true);
+        $data = json_decode($json, true);
 
         if (! is_array($data) || ($data['schema'] ?? null) !== 1) {
             return null;
@@ -387,14 +432,14 @@ final class Graph
         return $graph;
     }
 
-    public function save(string $path): bool
+    /**
+     * Serialises the graph to its JSON on-disk form. Returns `null` if the
+     * payload can't be encoded (extremely rare — pathological UTF-8 only).
+     * Persistence is the caller's responsibility: write the returned bytes
+     * through whatever `State` implementation is in play.
+     */
+    public function encode(): ?string
     {
-        $dir = dirname($path);
-
-        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
-            return false;
-        }
-
         $payload = [
             'schema' => 1,
             'fingerprint' => $this->fingerprint,
@@ -403,25 +448,9 @@ final class Graph
             'baselines' => $this->baselines,
         ];
 
-        $tmp = $path.'.'.bin2hex(random_bytes(4)).'.tmp';
-
         $json = json_encode($payload, JSON_UNESCAPED_SLASHES);
 
-        if ($json === false) {
-            return false;
-        }
-
-        if (@file_put_contents($tmp, $json) === false) {
-            return false;
-        }
-
-        if (! @rename($tmp, $path)) {
-            @unlink($tmp);
-
-            return false;
-        }
-
-        return true;
+        return $json === false ? null : $json;
     }
 
     /**

src/Plugins/Tia/ResultCollector.php

@@ -14,7 +14,7 @@ namespace Pest\Plugins\Tia;
 final class ResultCollector
 {
     /**
-     * @var array<string, array{status: int, message: string, time: float}>
+     * @var array<string, array{status: int, message: string, time: float, assertions: int}>
      */
     private array $results = [];
 
@@ -83,13 +83,34 @@ final class ResultCollector
     }
 
     /**
-     * @return array<string, array{status: int, message: string, time: float}>
+     * @return array<string, array{status: int, message: string, time: float, assertions: int}>
      */
     public function all(): array
     {
         return $this->results;
     }
 
+    public function recordAssertions(string $testId, int $assertions): void
+    {
+        if (isset($this->results[$testId])) {
+            $this->results[$testId]['assertions'] = $assertions;
+        }
+    }
+
+    /**
+     * Injects externally-collected results (e.g. partials flushed by parallel
+     * workers) into this collector so the parent can persist them in the same
+     * snapshot pass as non-parallel runs.
+     *
+     * @param  array<string, array{status: int, message: string, time: float, assertions: int}>  $results
+     */
+    public function merge(array $results): void
+    {
+        foreach ($results as $testId => $result) {
+            $this->results[$testId] = $result;
+        }
+    }
+
     public function reset(): void
     {
         $this->results = [];
@@ -97,6 +118,17 @@ final class ResultCollector
         $this->startTime = null;
     }
 
+    /**
+     * Called by the Finished subscriber after a test's outcome + assertion
+     * events have all fired. Clears the "currently recording" pointer so
+     * the next test's events don't get mis-attributed.
+     */
+    public function finishTest(): void
+    {
+        $this->currentTestId = null;
+        $this->startTime = null;
+    }
+
     private function record(int $status, string $message): void
     {
         if ($this->currentTestId === null) {
@@ -107,13 +139,17 @@ final class ResultCollector
             ? round(microtime(true) - $this->startTime, 3)
             : 0.0;
 
+        // PHPUnit can fire more than one outcome event per test — the
+        // canonical case is a risky pass (`Passed` then `ConsideredRisky`).
+        // Last-wins semantics preserve the most specific status; the
+        // existing assertion count (if any) survives the overwrite.
+        $existing = $this->results[$this->currentTestId] ?? null;
+
         $this->results[$this->currentTestId] = [
             'status' => $status,
             'message' => $message,
             'time' => $time,
+            'assertions' => $existing['assertions'] ?? 0,
         ];
-
-        $this->currentTestId = null;
-        $this->startTime = null;
     }
 }

src/Plugins/Tia/Storage.php

@@ -0,0 +1,170 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+/**
+ * Resolves TIA's on-disk state directory.
+ *
+ * Default location: `$HOME/.pest/tia/<project-key>/`. Keeping state in the
+ * user's home directory (rather than under `vendor/pestphp/pest/`) means:
+ *
+ *   - `composer install` / path-repo reinstalls don't wipe the graph.
+ *   - The state lives outside the project tree, so there is nothing for
+ *     users to gitignore or accidentally commit.
+ *   - Multiple worktrees of the same repo share one cache naturally.
+ *
+ * The project key is derived from the git origin URL when available — a
+ * CI workflow running on `github.com/org/repo` and a developer's clone
+ * of the same remote both compute the *same* key, which is what lets the
+ * CI-uploaded baseline line up with the dev-side reader. When the project
+ * is not in git, the key falls back to a hash of the absolute path so
+ * unrelated projects on the same machine stay isolated.
+ *
+ * When no home directory is resolvable (`HOME` / `USERPROFILE` both
+ * unset — the tests-tia sandboxes strip these deliberately, and some
+ * locked-down CI environments do the same), state falls back to
+ * `<projectRoot>/.pest/tia/`. That path is project-local but still
+ * survives composer installs, so the degradation is graceful.
+ *
+ * @internal
+ */
+final class Storage
+{
+    /**
+     * Directory where TIA's State blobs live for `$projectRoot`.
+     */
+    public static function tempDir(string $projectRoot): string
+    {
+        $home = self::homeDir();
+
+        if ($home === null) {
+            return $projectRoot
+                .DIRECTORY_SEPARATOR.'.pest'
+                .DIRECTORY_SEPARATOR.'tia';
+        }
+
+        return $home
+            .DIRECTORY_SEPARATOR.'.pest'
+            .DIRECTORY_SEPARATOR.'tia'
+            .DIRECTORY_SEPARATOR.self::projectKey($projectRoot);
+    }
+
+    /**
+     * OS-neutral home directory — `HOME` on Unix, `USERPROFILE` on
+     * Windows. Returns null if neither resolves to an existing
+     * directory, in which case callers fall back to project-local state.
+     */
+    private static function homeDir(): ?string
+    {
+        foreach (['HOME', 'USERPROFILE'] as $key) {
+            $value = getenv($key);
+
+            if (is_string($value) && $value !== '' && is_dir($value)) {
+                return rtrim($value, '/\\');
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Folder name for `$projectRoot` under `~/.pest/tia/`.
+     *
+     * Strategy — each step rules out a class of collision:
+     *
+     *   1. If the project has a git origin URL, use a **normalised** form
+     *      (`host/org/repo`, lowercased, no `.git` suffix) as the input.
+     *      `git@github.com:foo/bar.git`, `ssh://git@github.com/foo/bar`
+     *      and `https://github.com/foo/bar` all collapse to
+     *      `github.com/foo/bar` — three developers cloning the same repo
+     *      by different transports share one cache, which is what we want.
+     *   2. Otherwise, use the canonicalised absolute path (`realpath`).
+     *      Two unrelated `app/` checkouts under different parent folders
+     *      have different realpaths → different hashes → isolated.
+     *   3. Hash the chosen input with sha256 and keep the first 16 hex
+     *      chars — 64 bits of entropy makes accidental collision
+     *      astronomically unlikely even across thousands of projects.
+     *   4. Prefix with a slug of the project basename so `ls ~/.pest/tia/`
+     *      is readable; the slug is cosmetic only, all isolation comes
+     *      from the hash.
+     *
+     * Result: `myapp-a1b2c3d4e5f67890`.
+     */
+    private static function projectKey(string $projectRoot): string
+    {
+        $origin = self::originIdentity($projectRoot);
+
+        $realpath = @realpath($projectRoot);
+        $input = $origin ?? ($realpath === false ? $projectRoot : $realpath);
+
+        $hash = substr(hash('sha256', $input), 0, 16);
+        $slug = self::slug(basename($projectRoot));
+
+        return $slug === '' ? $hash : $slug.'-'.$hash;
+    }
+
+    /**
+     * Canonical git origin identity for `$projectRoot`, or null when
+     * no origin URL can be parsed. The returned form is
+     * `host/org/repo` (lowercased, `.git` stripped) so SSH / HTTPS / git
+     * protocol clones of the same remote produce the same value.
+     */
+    private static function originIdentity(string $projectRoot): ?string
+    {
+        $url = self::rawOriginUrl($projectRoot);
+
+        if ($url === null) {
+            return null;
+        }
+
+        // git@host:org/repo(.git)
+        if (preg_match('#^[\w.-]+@([\w.-]+):([\w./-]+?)(?:\.git)?/?$#', $url, $m) === 1) {
+            return strtolower($m[1].'/'.$m[2]);
+        }
+
+        // scheme://[user@]host[:port]/org/repo(.git)  — https, ssh, git, file
+        if (preg_match('#^[a-z]+://(?:[^@/]+@)?([^/:]+)(?::\d+)?/([\w./-]+?)(?:\.git)?/?$#i', $url, $m) === 1) {
+            return strtolower($m[1].'/'.$m[2]);
+        }
+
+        // Unrecognised form — hash the raw URL so different inputs still
+        // diverge, but lowercased so the only variance is intentional.
+        return strtolower($url);
+    }
+
+    private static function rawOriginUrl(string $projectRoot): ?string
+    {
+        $config = $projectRoot.DIRECTORY_SEPARATOR.'.git'.DIRECTORY_SEPARATOR.'config';
+
+        if (! is_file($config)) {
+            return null;
+        }
+
+        $raw = @file_get_contents($config);
+
+        if ($raw === false) {
+            return null;
+        }
+
+        if (preg_match('/\[remote "origin"\][^\[]*?url\s*=\s*(\S+)/s', $raw, $match) === 1) {
+            return trim($match[1]);
+        }
+
+        return null;
+    }
+
+    /**
+     * Filesystem-safe kebab of `$name`. Cosmetic only — used as a
+     * human-readable prefix on the hash so `~/.pest/tia/` lists
+     * recognisable folders.
+     */
+    private static function slug(string $name): string
+    {
+        $slug = strtolower($name);
+        $slug = preg_replace('/[^a-z0-9]+/', '-', $slug) ?? '';
+
+        return trim($slug, '-');
+    }
+}

src/Plugins/Tia/WatchDefaults/Laravel.php

@@ -60,6 +60,10 @@ final readonly class Laravel implements WatchDefault
 
             // Blade templates — compiled to cache, source file not executed.
             'resources/views/**/*.blade.php' => [$featurePath],
+            // Email templates are nested under views/email or views/emails
+            // by convention and power mailable tests that render markup.
+            'resources/views/email/**/*.blade.php' => [$featurePath],
+            'resources/views/emails/**/*.blade.php' => [$featurePath],
 
             // Translations — JSON translations read via file_get_contents,
             // PHP translations loaded via include (but during boot).

src/Plugins/Tia/WatchDefaults/Livewire.php

@@ -29,6 +29,10 @@ final readonly class Livewire implements WatchDefault
             // Livewire views live alongside Blade views or in a dedicated dir.
             'resources/views/livewire/**/*.blade.php' => [$testPath],
             'resources/views/components/**/*.blade.php' => [$testPath],
+            // Volt's second default mount — single-file components used as
+            // full-page routes. Missing this means editing a Volt page
+            // doesn't re-run its tests.
+            'resources/views/pages/**/*.blade.php' => [$testPath],
 
             // Livewire JS interop / Alpine plugins.
             'resources/js/**/*.js' => [$testPath],

src/Plugins/Tia/WatchDefaults/Php.php

@@ -25,9 +25,14 @@ final readonly class Php implements WatchDefault
 
         return [
             // Environment files — can change DB drivers, feature flags,
-            // queue connections, etc. Not PHP, not fingerprinted.
+            // queue connections, etc. Not PHP, not fingerprinted. Covers
+            // the local-override variants (`.env.local`, `.env.testing.local`)
+            // that both Laravel and Symfony recommend for machine-specific
+            // config.
             '.env' => [$testPath],
             '.env.testing' => [$testPath],
+            '.env.local' => [$testPath],
+            '.env.*.local' => [$testPath],
 
             // Docker / CI — can affect integration test infrastructure.
             'docker-compose.yml' => [$testPath],

src/Plugins/Tia/WatchDefaults/Symfony.php

@@ -46,7 +46,11 @@ final readonly class Symfony implements WatchDefault
             'src/Kernel.php' => [$testPath],
 
             // Migrations — run during setUp (before coverage window).
+            // DoctrineMigrationsBundle's default is `migrations/` at the
+            // project root; many Symfony projects relocate to
+            // `src/Migrations/` — both covered.
             'migrations/**/*.php' => [$testPath],
+            'src/Migrations/**/*.php' => [$testPath],
 
             // Twig templates — compiled, source not PHP-executed.
             'templates/**/*.html.twig' => [$testPath],

src/Subscribers/EnsureTiaAssertionsAreRecordedOnFinished.php

@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Code\TestMethod;
+use PHPUnit\Event\Test\Finished;
+use PHPUnit\Event\Test\FinishedSubscriber;
+
+/**
+ * Fires last for each test, after the outcome subscribers. Records the exact
+ * assertion count so replay can emit the same `addToAssertionCount()` instead
+ * of a hardcoded value.
+ *
+ * @internal
+ */
+final readonly class EnsureTiaAssertionsAreRecordedOnFinished implements FinishedSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Finished $event): void
+    {
+        $test = $event->test();
+
+        if ($test instanceof TestMethod) {
+            $this->collector->recordAssertions(
+                $test->className().'::'.$test->methodName(),
+                $event->numberOfAssertionsPerformed(),
+            );
+        }
+
+        // Close the "currently recording" window on Finished so the next
+        // test's events don't get mis-attributed. Keeping the pointer open
+        // through the outcome subscribers is what lets a late-firing
+        // `ConsideredRisky` overwrite an earlier `Passed`.
+        $this->collector->finishTest();
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnErrored.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\Errored;
+use PHPUnit\Event\Test\ErroredSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnErrored implements ErroredSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Errored $event): void
+    {
+        $this->collector->testErrored($event->throwable()->message());
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnFailed.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\Failed;
+use PHPUnit\Event\Test\FailedSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnFailed implements FailedSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Failed $event): void
+    {
+        $this->collector->testFailed($event->throwable()->message());
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnIncomplete.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\MarkedIncomplete;
+use PHPUnit\Event\Test\MarkedIncompleteSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnIncomplete implements MarkedIncompleteSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(MarkedIncomplete $event): void
+    {
+        $this->collector->testIncomplete($event->throwable()->message());
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnPassed.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\Passed;
+use PHPUnit\Event\Test\PassedSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnPassed implements PassedSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Passed $event): void
+    {
+        $this->collector->testPassed();
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnRisky.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\ConsideredRisky;
+use PHPUnit\Event\Test\ConsideredRiskySubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnRisky implements ConsideredRiskySubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(ConsideredRisky $event): void
+    {
+        $this->collector->testRisky($event->message());
+    }
+}

src/Subscribers/EnsureTiaResultIsRecordedOnSkipped.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Test\Skipped;
+use PHPUnit\Event\Test\SkippedSubscriber;
+
+/**
+ * @internal
+ */
+final readonly class EnsureTiaResultIsRecordedOnSkipped implements SkippedSubscriber
+{
+    public function __construct(private ResultCollector $collector) {}
+
+    public function notify(Skipped $event): void
+    {
+        $this->collector->testSkipped($event->message());
+    }
+}

src/Subscribers/EnsureTiaResultsAreCollected.php

@@ -6,81 +6,30 @@ namespace Pest\Subscribers;
 
 use Pest\Plugins\Tia\ResultCollector;
 use PHPUnit\Event\Code\TestMethod;
-use PHPUnit\Event\Test\ConsideredRisky;
-use PHPUnit\Event\Test\ConsideredRiskySubscriber;
-use PHPUnit\Event\Test\Errored;
-use PHPUnit\Event\Test\ErroredSubscriber;
-use PHPUnit\Event\Test\Failed;
-use PHPUnit\Event\Test\FailedSubscriber;
-use PHPUnit\Event\Test\MarkedIncomplete;
-use PHPUnit\Event\Test\MarkedIncompleteSubscriber;
-use PHPUnit\Event\Test\Passed;
-use PHPUnit\Event\Test\PassedSubscriber;
 use PHPUnit\Event\Test\Prepared;
 use PHPUnit\Event\Test\PreparedSubscriber;
-use PHPUnit\Event\Test\Skipped;
-use PHPUnit\Event\Test\SkippedSubscriber;
 
 /**
- * Feeds per-test outcomes (status + message + time) into the TIA
- * `ResultCollector` so the graph can persist them for faithful replay.
+ * Starts a per-test recording window on Prepared. Sibling subscribers
+ * (`EnsureTia*`) close it with the outcome and the assertion count so the
+ * graph can persist everything needed for faithful replay.
+ *
+ * Why one subscriber per event: PHPUnit's `TypeMap::map()` picks only the
+ * first subscriber interface it finds on a class, so one class cannot fan
+ * out to multiple events — each event needs its own subscriber class.
  *
  * @internal
  */
-final class EnsureTiaResultsAreCollected implements
-    ConsideredRiskySubscriber,
-    ErroredSubscriber,
-    FailedSubscriber,
-    MarkedIncompleteSubscriber,
-    PassedSubscriber,
-    PreparedSubscriber,
-    SkippedSubscriber
+final readonly class EnsureTiaResultsAreCollected implements PreparedSubscriber
 {
-    public function __construct(private readonly ResultCollector $collector) {}
+    public function __construct(private ResultCollector $collector) {}
 
-    public function notify(Prepared|Passed|Failed|Errored|Skipped|MarkedIncomplete|ConsideredRisky $event): void
+    public function notify(Prepared $event): void
     {
-        if ($event instanceof Prepared) {
         $test = $event->test();
 
         if ($test instanceof TestMethod) {
             $this->collector->testPrepared($test->className().'::'.$test->methodName());
         }
-
-            return;
-        }
-
-        if ($event instanceof Passed) {
-            $this->collector->testPassed();
-
-            return;
-        }
-
-        if ($event instanceof Failed) {
-            $this->collector->testFailed($event->throwable()->message());
-
-            return;
-        }
-
-        if ($event instanceof Errored) {
-            $this->collector->testErrored($event->throwable()->message());
-
-            return;
-        }
-
-        if ($event instanceof Skipped) {
-            $this->collector->testSkipped($event->message());
-
-            return;
-        }
-
-        if ($event instanceof MarkedIncomplete) {
-            $this->collector->testIncomplete($event->throwable()->message());
-
-            return;
-        }
-
-        // Last possible type: ConsideredRisky (all others returned above).
-        $this->collector->testRisky($event->message()); // @phpstan-ignore method.notFound
     }
 }

src/Support/Coverage.php

@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Pest\Support;
 
 use Pest\Exceptions\ShouldNotHappen;
+use Pest\Plugins\Tia\CoverageMerger;
 use SebastianBergmann\CodeCoverage\CodeCoverage;
 use SebastianBergmann\CodeCoverage\Node\Directory;
 use SebastianBergmann\CodeCoverage\Node\File;
@@ -88,6 +89,12 @@ final class Coverage
             throw ShouldNotHappen::fromMessage(sprintf('Coverage not found in path: %s.', $reportPath));
         }
 
+        // If TIA's marker is present, this run executed only the affected
+        // tests. Merge their fresh coverage slice into the cached full-run
+        // snapshot (stored by the previous `--tia --coverage` pass) so the
+        // report reflects the entire suite, not just what re-ran.
+        CoverageMerger::applyIfMarked($reportPath);
+
         /** @var CodeCoverage $codeCoverage */
         $codeCoverage = require $reportPath;
         unlink($reportPath);

src/Support/XdebugGuard.php

@@ -0,0 +1,178 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Support;
+
+use Composer\XdebugHandler\XdebugHandler;
+use Pest\Plugins\Tia;
+use Pest\Plugins\Tia\Fingerprint;
+use Pest\Plugins\Tia\Graph;
+use Pest\Plugins\Tia\Storage;
+
+/**
+ * Re-execs the PHP process without Xdebug on TIA replay runs, matching the
+ * behaviour of composer, phpstan, rector, psalm and pint.
+ *
+ * Xdebug imposes a 30–50% runtime tax on every PHP process that loads it —
+ * even when nothing is actively tracing, profiling or breaking. Plain `pest`
+ * users might rely on Xdebug being loaded (IDE breakpoints, step-through
+ * debugging, custom tooling), so we intentionally leave non-TIA runs alone.
+ *
+ * The guard engages only when ALL of these hold:
+ *   1. `--tia` is present in argv.
+ *   2. No `--fresh` flag (forced record always drives the coverage
+ *      driver; dropping Xdebug would break the recording).
+ *   3. No `--coverage*` flag (coverage runs need the driver regardless).
+ *   4. A valid graph already exists on disk AND its structural fingerprint
+ *      matches the current environment — i.e. TIA will replay rather than
+ *      record. Record runs need the driver.
+ *   5. Xdebug's configured mode is either empty or exactly `['coverage']`.
+ *      Any other mode (debug, develop, trace, profile, gcstats) signals the
+ *      user wants Xdebug for reasons unrelated to coverage, so we leave it
+ *      alone even on replay.
+ *
+ * `PEST_ALLOW_XDEBUG=1` remains an explicit manual override; it is honoured
+ * natively by `composer/xdebug-handler`.
+ *
+ * @internal
+ */
+final class XdebugGuard
+{
+    /**
+     * Call as early as possible after composer autoload, before any Pest
+     * class beyond the autoloader is touched. Safe when Xdebug is not
+     * loaded (returns immediately) and when `composer/xdebug-handler` is
+     * unavailable (defensive `class_exists` check).
+     */
+    public static function maybeDrop(string $projectRoot): void
+    {
+        if (! class_exists(XdebugHandler::class)) {
+            return;
+        }
+
+        if (! extension_loaded('xdebug')) {
+            return;
+        }
+
+        if (! self::xdebugIsCoverageOnly()) {
+            return;
+        }
+
+        $argv = is_array($_SERVER['argv'] ?? null) ? $_SERVER['argv'] : [];
+
+        if (! self::runLooksDroppable($argv, $projectRoot)) {
+            return;
+        }
+
+        (new XdebugHandler('pest'))->check();
+    }
+
+    /**
+     * True when Xdebug 3+ is running in coverage-only mode (or empty). False
+     * for older Xdebug without `xdebug_info` — be conservative and leave it
+     * loaded; we can't prove the mode is safe to drop.
+     */
+    private static function xdebugIsCoverageOnly(): bool
+    {
+        if (! function_exists('xdebug_info')) {
+            return false;
+        }
+
+        $modes = @xdebug_info('mode');
+
+        if (! is_array($modes)) {
+            return false;
+        }
+
+        $modes = array_values(array_filter($modes, is_string(...)));
+
+        if ($modes === []) {
+            return true;
+        }
+
+        return $modes === ['coverage'];
+    }
+
+    /**
+     * Encodes the argv-based rules: `--tia` must be present, no coverage
+     * flag, no forced rebuild, and TIA must be about to replay rather than
+     * record. Plain `pest` (and anything else without `--tia`) keeps Xdebug
+     * loaded so non-TIA users aren't surprised by behaviour changes.
+     *
+     * @param  array<int, mixed>  $argv
+     */
+    private static function runLooksDroppable(array $argv, string $projectRoot): bool
+    {
+        $hasTia = false;
+
+        foreach ($argv as $value) {
+            if (! is_string($value)) {
+                continue;
+            }
+
+            if ($value === '--coverage'
+                || str_starts_with($value, '--coverage=')
+                || str_starts_with($value, '--coverage-')) {
+                return false;
+            }
+
+            if ($value === '--fresh') {
+                return false;
+            }
+
+            if ($value === '--tia') {
+                $hasTia = true;
+            }
+        }
+
+        if (! $hasTia) {
+            return false;
+        }
+
+        return self::tiaWillReplay($projectRoot);
+    }
+
+    /**
+     * True when a valid TIA graph already lives on disk AND its structural
+     * fingerprint matches the current environment. Any other outcome
+     * (missing graph, unreadable JSON, structural drift) means TIA will
+     * record and the driver must stay loaded.
+     */
+    private static function tiaWillReplay(string $projectRoot): bool
+    {
+        $path = self::graphPath($projectRoot);
+
+        if (! is_file($path)) {
+            return false;
+        }
+
+        $json = @file_get_contents($path);
+
+        if ($json === false) {
+            return false;
+        }
+
+        $graph = Graph::decode($json, $projectRoot);
+
+        if (! $graph instanceof Graph) {
+            return false;
+        }
+
+        return Fingerprint::structuralMatches(
+            $graph->fingerprint(),
+            Fingerprint::compute($projectRoot),
+        );
+    }
+
+    /**
+     * On-disk location of the TIA graph — delegates to {@see Storage} so
+     * the writer (TIA's bootstrapper) and this reader stay in sync
+     * without a runtime container lookup (the container isn't booted yet
+     * at this point).
+     */
+    private static function graphPath(string $projectRoot): string
+    {
+        return Storage::tempDir($projectRoot).DIRECTORY_SEPARATOR.Tia::KEY_GRAPH;
+    }
+}

src/TestCaseFilters/TiaTestCaseFilter.php

@@ -1,65 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Pest\TestCaseFilters;
-
-use Pest\Contracts\TestCaseFilter;
-use Pest\Plugins\Tia\Graph;
-
-/**
- * Accepts a test file in one of three cases:
- *
- *   1. The file falls outside the project root (we cannot reason about it, so
- *      stay safe and run it).
- *   2. The graph has no record of the file — this is a new test that was
- *      never part of a recording run, so we accept it by default. Skipping
- *      unknown tests would be a correctness hazard (developers add tests and
- *      TIA would silently not run them).
- *   3. The graph knows the file AND it is in the affected set.
- *
- * @internal
- */
-final readonly class TiaTestCaseFilter implements TestCaseFilter
-{
-    /**
-     * @param  array<string, true>  $affectedTestFiles  Keys are project-relative test file paths.
-     */
-    public function __construct(
-        private string $projectRoot,
-        private Graph $graph,
-        private array $affectedTestFiles,
-    ) {}
-
-    public function accept(string $testCaseFilename): bool
-    {
-        $rel = $this->relative($testCaseFilename);
-
-        if ($rel === null) {
-            return true;
-        }
-
-        if (! $this->graph->knowsTest($rel)) {
-            return true;
-        }
-
-        return isset($this->affectedTestFiles[$rel]);
-    }
-
-    private function relative(string $path): ?string
-    {
-        $real = @realpath($path);
-
-        if ($real === false) {
-            $real = $path;
-        }
-
-        $root = rtrim($this->projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
-
-        if (! str_starts_with($real, $root)) {
-            return null;
-        }
-
-        return str_replace(DIRECTORY_SEPARATOR, '/', substr($real, strlen($root)));
-    }
-}

tests-tia/AffectedSetTest.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+use Pest\TestsTia\Support\Sandbox;
+
+/*
+ * Mutating a source file should narrow replay to the tests that depend
+ * on it. Untouched areas of the suite keep cache-hitting.
+ */
+
+test('editing a source file marks only its dependents as affected', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        $sandbox->pest(['--tia']);
+
+        $sandbox->write('src/Math.php', <<<'PHP'
+<?php
+
+declare(strict_types=1);
+
+namespace App;
+
+final class Math
+{
+    public static function add(int $a, int $b): int
+    {
+        return $a + $b;
+    }
+
+    public static function sub(int $a, int $b): int
+    {
+        return $a - $b;
+    }
+}
+PHP);
+
+        $process = $sandbox->pest(['--tia']);
+
+        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
+        expect(tiaOutput($process))->toMatch('/2 affected,\s*1 replayed/');
+    });
+});
+
+test('adding a new test file runs the new test + replays the rest', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        $sandbox->pest(['--tia']);
+
+        $sandbox->write('tests/ExtraTest.php', <<<'PHP'
+<?php
+
+declare(strict_types=1);
+
+test('extra smoke', function () {
+    expect(true)->toBeTrue();
+});
+PHP);
+
+        $process = $sandbox->pest(['--tia']);
+
+        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
+        expect(tiaOutput($process))->toMatch('/1 affected,\s*3 replayed/');
+    });
+});

tests-tia/FingerprintDriftTest.php

@@ -0,0 +1,52 @@
+<?php
+
+declare(strict_types=1);
+
+use Pest\TestsTia\Support\Sandbox;
+
+/*
+ * Fingerprint splits into structural vs environmental. Hand-forge each
+ * drift flavour on a valid graph and assert the right branch fires.
+ */
+
+test('structural drift discards the graph entirely', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        $sandbox->pest(['--tia']);
+
+        $graphPath = $sandbox->path().'/.pest/tia/graph.json';
+        $graph = json_decode((string) file_get_contents($graphPath), true);
+        $graph['fingerprint']['structural']['composer_lock'] = str_repeat('0', 32);
+        file_put_contents($graphPath, json_encode($graph));
+
+        $process = $sandbox->pest(['--tia']);
+
+        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
+        expect(tiaOutput($process))->toContain('graph structure outdated');
+    });
+});
+
+test('environmental drift keeps edges, drops results', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        $sandbox->pest(['--tia']);
+
+        $graphPath = $sandbox->path().'/.pest/tia/graph.json';
+        $graph = json_decode((string) file_get_contents($graphPath), true);
+
+        $edgeCountBefore = count($graph['edges']);
+
+        $graph['fingerprint']['environmental']['php_minor'] = '7.4';
+        $graph['fingerprint']['environmental']['extensions'] = str_repeat('0', 32);
+        file_put_contents($graphPath, json_encode($graph));
+
+        $process = $sandbox->pest(['--tia']);
+
+        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
+        expect(tiaOutput($process))->toContain('env differs from baseline');
+        expect(tiaOutput($process))->toContain('results dropped, edges reused');
+
+        $graphAfter = $sandbox->graph();
+        expect(count($graphAfter['edges']))->toBe($edgeCountBefore);
+        expect($graphAfter['fingerprint']['environmental']['php_minor'])
+            ->not()->toBe('7.4');
+    });
+});

tests-tia/Fixtures/sample-project/composer.json

@@ -0,0 +1,27 @@
+{
+    "name": "pest/tia-sample-project",
+    "type": "project",
+    "description": "Throw-away fixture used by tests-tia to exercise TIA end-to-end.",
+    "require": {
+        "php": "^8.3"
+    },
+    "autoload": {
+        "psr-4": {
+            "App\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Tests\\": "tests/"
+        }
+    },
+    "config": {
+        "sort-packages": true,
+        "allow-plugins": {
+            "pestphp/pest-plugin": true,
+            "php-http/discovery": true
+        }
+    },
+    "minimum-stability": "dev",
+    "prefer-stable": true
+}

tests-tia/Fixtures/sample-project/phpunit.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+         cacheDirectory=".phpunit.cache"
+         executionOrder="depends,defects"
+         failOnRisky="false"
+         failOnWarning="false"
+         displayDetailsOnTestsThatTriggerWarnings="true"
+         displayDetailsOnTestsThatTriggerNotices="true">
+    <testsuites>
+        <testsuite name="default">
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    <source>
+        <include>
+            <directory>src</directory>
+        </include>
+    </source>
+</phpunit>

tests-tia/Fixtures/sample-project/src/Greeter.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App;
+
+final class Greeter
+{
+    public static function greet(string $name): string
+    {
+        return sprintf('Hello, %s!', $name);
+    }
+}

tests-tia/Fixtures/sample-project/src/Math.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App;
+
+final class Math
+{
+    public static function add(int $a, int $b): int
+    {
+        return $a + $b;
+    }
+}

tests-tia/Fixtures/sample-project/tests/GreeterTest.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Greeter;
+
+test('greeter greets', function () {
+    expect(Greeter::greet('Nuno'))->toBe('Hello, Nuno!');
+});

tests-tia/Fixtures/sample-project/tests/MathTest.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Math;
+
+test('math add', function () {
+    expect(Math::add(2, 3))->toBe(5);
+});
+
+test('math add negative', function () {
+    expect(Math::add(-1, 1))->toBe(0);
+});

tests-tia/Fixtures/sample-project/tests/Pest.php

@@ -0,0 +1,7 @@
+<?php
+
+declare(strict_types=1);
+
+// Intentionally minimal — tests-tia exercises TIA against the simplest
+// possible Pest harness. Anything more and we end up debugging the
+// fixture instead of the feature under test.

tests-tia/RebuildTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+use Pest\TestsTia\Support\Sandbox;
+
+/*
+ * `--tia --fresh` short-circuits whatever graph is on disk and records
+ * from scratch. Used when the user knows the cache is wrong.
+ */
+
+test('--tia --fresh forces record mode even with a valid graph', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        $sandbox->pest(['--tia']);
+        expect($sandbox->hasGraph())->toBeTrue();
+
+        $graphBefore = $sandbox->graph();
+
+        $process = $sandbox->pest(['--tia', '--fresh']);
+
+        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
+        expect(tiaOutput($process))->toContain('recording dependency graph');
+
+        $graphAfter = $sandbox->graph();
+        expect(array_keys($graphAfter['edges']))
+            ->toEqualCanonicalizing(array_keys($graphBefore['edges']));
+    });
+});

tests-tia/RecordReplayTest.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+use Pest\TestsTia\Support\Sandbox;
+
+/*
+ * The canonical cycle:
+ *   1. Cold `--tia` run → record mode → graph written, tests pass.
+ *   2. Subsequent `--tia` runs → replay mode, every test cache-hits.
+ */
+
+test('cold run records the graph', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        $process = $sandbox->pest(['--tia']);
+
+        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
+        expect(tiaOutput($process))->toContain('recording dependency graph');
+        expect($sandbox->hasGraph())->toBeTrue();
+
+        $graph = $sandbox->graph();
+        expect($graph)->toHaveKey('edges');
+        expect(array_keys($graph['edges']))->toContain('tests/MathTest.php');
+        expect(array_keys($graph['edges']))->toContain('tests/GreeterTest.php');
+    });
+});
+
+test('warm run replays every test', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        // Cold pass: records edges AND snapshots results (series mode
+        // runs `snapshotTestResults` in the same `addOutput` pass).
+        $sandbox->pest(['--tia']);
+
+        $process = $sandbox->pest(['--tia']);
+
+        expect($process->isSuccessful())->toBeTrue(tiaOutput($process));
+        // Zero changes → only the `replayed` fragment appears in the
+        // recap; the `affected` fragment is omitted when count is 0.
+        expect(tiaOutput($process))->toMatch('/3 replayed/');
+        expect(tiaOutput($process))->not()->toMatch('/\d+ affected/');
+    });
+});

tests-tia/SourceRevertTest.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+use Pest\TestsTia\Support\Sandbox;
+
+/*
+ * Edit a source file, run TIA (tests re-run), revert to the original
+ * bytes, run again — the revert is itself a change vs the previous
+ * snapshot, so the affected tests re-execute rather than replaying the
+ * stale bad-version cache.
+ */
+
+test('reverting a modified file re-triggers its affected tests', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        $sandbox->pest(['--tia']);
+
+        $original = (string) file_get_contents($sandbox->path().'/src/Math.php');
+
+        $sandbox->write('src/Math.php', <<<'PHP'
+<?php
+
+declare(strict_types=1);
+
+namespace App;
+
+final class Math
+{
+    public static function add(int $a, int $b): int
+    {
+        return 999; // broken
+    }
+}
+PHP);
+
+        $broken = $sandbox->pest(['--tia']);
+        expect($broken->isSuccessful())->toBeFalse();
+
+        $sandbox->write('src/Math.php', $original);
+
+        $recovered = $sandbox->pest(['--tia']);
+
+        expect($recovered->isSuccessful())->toBeTrue(tiaOutput($recovered));
+        expect(tiaOutput($recovered))->toMatch('/2 affected,\s*1 replayed/');
+    });
+});

tests-tia/StatusReplayTest.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+use Pest\TestsTia\Support\Sandbox;
+
+/*
+ * Cached statuses + assertion counts should survive replay.
+ */
+
+test('assertion counts survive replay', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        $sandbox->pest(['--tia']);
+
+        $process = $sandbox->pest(['--tia']);
+        $output = tiaOutput($process);
+
+        // MathTest has 2 assertions, GreeterTest has 1 → 3 total.
+        // The "Tests: … (N assertions, … replayed)" banner should show 3.
+        expect($output)->toMatch('/\(3 assertions/');
+    });
+});
+
+test('breaking a test replays as a failure on the next run', function () {
+    tiaScenario(function (Sandbox $sandbox) {
+        // Prime.
+        $sandbox->pest(['--tia']);
+
+        // Break the test. Its test file's edge map still points at
+        // `src/Math.php`; editing the test file counts as a change
+        // and the test re-executes.
+        $sandbox->write('tests/MathTest.php', <<<'PHP'
+<?php
+
+declare(strict_types=1);
+
+use App\Math;
+
+test('math add', function () {
+    expect(Math::add(2, 3))->toBe(999); // wrong
+});
+
+test('math add negative', function () {
+    expect(Math::add(-1, 1))->toBe(0);
+});
+PHP);
+
+        $process = $sandbox->pest(['--tia']);
+
+        expect($process->isSuccessful())->toBeFalse();
+        expect(tiaOutput($process))->toContain('math add');
+    });
+});

tests-tia/Support/Sandbox.php

@@ -0,0 +1,447 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\TestsTia\Support;
+
+use RuntimeException;
+use Symfony\Component\Process\Process;
+
+/**
+ * Throw-away sandbox for a TIA end-to-end scenario.
+ *
+ * On first call in a test run, a shared "template" sandbox is created
+ * under the system temp dir and composer-installed against the host
+ * Pest source. Subsequent `::create()` calls clone the template — cheap
+ * (rcopy + git init) vs. running composer install per test.
+ *
+ * Each test owns its own clone; no cross-test state.
+ *
+ * Set `PEST_TIA_KEEP=1` to skip teardown so a failing scenario can be
+ * reproduced manually — the path is emitted to STDERR.
+ *
+ * @internal
+ */
+final class Sandbox
+{
+    private static ?string $templatePath = null;
+
+    private function __construct(private readonly string $path) {}
+
+    /**
+     * Eagerly provision the shared template. Call once from the harness
+     * bootstrap so parallel workers don't race on first `create()`.
+     */
+    public static function warmTemplate(): void
+    {
+        self::ensureTemplate();
+    }
+
+    public static function create(): self
+    {
+        $template = self::ensureTemplate();
+
+        $path = sys_get_temp_dir()
+            .DIRECTORY_SEPARATOR
+            .'pest-tia-sandbox-'
+            .bin2hex(random_bytes(4));
+
+        self::rcopy($template, $path);
+        self::bootstrapGit($path);
+
+        return new self($path);
+    }
+
+    public function path(): string
+    {
+        return $this->path;
+    }
+
+    public function write(string $relative, string $content): void
+    {
+        $absolute = $this->path.DIRECTORY_SEPARATOR.$relative;
+        $dir = dirname($absolute);
+
+        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
+            throw new RuntimeException("Cannot create {$dir}");
+        }
+
+        if (@file_put_contents($absolute, $content) === false) {
+            throw new RuntimeException("Cannot write {$absolute}");
+        }
+    }
+
+    public function delete(string $relative): void
+    {
+        $absolute = $this->path.DIRECTORY_SEPARATOR.$relative;
+
+        if (is_file($absolute)) {
+            @unlink($absolute);
+        }
+    }
+
+    /**
+     * @param  array<int, string>  $flags
+     */
+    public function pest(array $flags = []): Process
+    {
+        // Invoke Pest's bin script through PHP directly rather than the
+        // `vendor/bin/pest` symlink — `rcopy()` loses the `+x` bit when
+        // cloning the template. Going through `php` bypasses the exec
+        // check. Use `PHP_BINARY` (not a bare `php`) so the sandbox
+        // executes under the same interpreter that launched the outer
+        // test suite — otherwise macOS multi-version setups (Herd, brew,
+        // asdf, …) fall back to the first `php` on `$PATH`, which often
+        // lacks the coverage driver TIA's record mode needs.
+        $process = new Process(
+            [PHP_BINARY, 'vendor/pestphp/pest/bin/pest', ...$flags],
+            $this->path,
+            [
+                // Strip any CI signal so TIA doesn't suppress instructions.
+                'GITHUB_ACTIONS' => '',
+                'GITLAB_CI' => '',
+                'CIRCLECI' => '',
+                // Force TIA's Storage to fall back to the sandbox-local
+                // `.pest/tia/` layout. Without this, every sandbox run
+                // would dump state into the developer's real home dir
+                // (`~/.pest/tia/`), polluting it and making tests
+                // non-hermetic.
+                'HOME' => '',
+                'USERPROFILE' => '',
+            ],
+        );
+        $process->setTimeout(120.0);
+        $process->run();
+
+        return $process;
+    }
+
+    /**
+     * @return array<string, mixed>|null
+     */
+    public function graph(): ?array
+    {
+        $path = $this->path.'/.pest/tia/graph.json';
+
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $raw = @file_get_contents($path);
+
+        if ($raw === false) {
+            return null;
+        }
+
+        $decoded = json_decode($raw, true);
+
+        return is_array($decoded) ? $decoded : null;
+    }
+
+    public function hasGraph(): bool
+    {
+        return $this->graph() !== null;
+    }
+
+    /**
+     * @param  array<int, string>  $args
+     */
+    public function git(array $args): Process
+    {
+        $process = new Process(['git', ...$args], $this->path);
+        $process->setTimeout(30.0);
+        $process->run();
+
+        return $process;
+    }
+
+    public function destroy(): void
+    {
+        if (getenv('PEST_TIA_KEEP') === '1') {
+            fwrite(STDERR, "[PEST_TIA_KEEP] sandbox: {$this->path}\n");
+
+            return;
+        }
+
+        if (is_dir($this->path)) {
+            self::rrmdir($this->path);
+        }
+    }
+
+    /**
+     * Lazily provisions a once-per-process template with composer already
+     * installed against the host Pest source. Every sandbox clone copies
+     * from here, avoiding a ~30s composer install per test.
+     */
+    private static function ensureTemplate(): string
+    {
+        if (self::$templatePath !== null && is_dir(self::$templatePath.'/vendor')) {
+            return self::$templatePath;
+        }
+
+        // Cache key includes a fingerprint of the host Pest source tree —
+        // when we edit Pest internals, the key changes, old templates
+        // become orphaned, the new template rebuilds. Without this, a
+        // stale template with yesterday's Pest code silently masks today's
+        // code under test.
+        $template = sys_get_temp_dir()
+            .DIRECTORY_SEPARATOR
+            .'pest-tia-template-'
+            .self::hostFingerprint();
+
+        // Serialise template creation across parallel paratest workers.
+        // Without the lock, three workers hitting `ensureTemplate()`
+        // simultaneously each see "no vendor yet → rebuild", stomp on
+        // each other's composer install, and produce half-written
+        // fixtures. `flock` on a sibling lockfile keeps it to one
+        // builder; the others block, then observe the finished
+        // template and skip straight to the fast path.
+        $lockPath = sys_get_temp_dir().DIRECTORY_SEPARATOR.'pest-tia-template.lock';
+        $lock = fopen($lockPath, 'c');
+
+        if ($lock === false) {
+            throw new RuntimeException('Cannot open template lock at '.$lockPath);
+        }
+
+        flock($lock, LOCK_EX);
+
+        try {
+            // Re-check after acquiring the lock — another worker may have
+            // just finished the build while we were waiting.
+            if (is_dir($template.'/vendor')) {
+                self::$templatePath = $template;
+
+                return $template;
+            }
+
+            // Garbage-collect every older template keyed by a different
+            // fingerprint so /tmp doesn't accumulate a 200 MB graveyard
+            // over a month of edits.
+            foreach (glob(sys_get_temp_dir().DIRECTORY_SEPARATOR.'pest-tia-template-*') ?: [] as $orphan) {
+                if ($orphan !== $template) {
+                    self::rrmdir($orphan);
+                }
+            }
+
+            if (is_dir($template)) {
+                self::rrmdir($template);
+            }
+
+            $fixture = __DIR__.'/../Fixtures/sample-project';
+
+            if (! is_dir($fixture)) {
+                throw new RuntimeException('Missing fixture at '.$fixture);
+            }
+
+            if (! @mkdir($template, 0755, true) && ! is_dir($template)) {
+                throw new RuntimeException('Cannot create template at '.$template);
+            }
+
+            self::rcopy($fixture, $template);
+            self::wireHostPest($template);
+            self::composerInstall($template);
+
+            self::$templatePath = $template;
+
+            return $template;
+        } finally {
+            flock($lock, LOCK_UN);
+            fclose($lock);
+        }
+    }
+
+    private static function wireHostPest(string $path): void
+    {
+        $hostRoot = realpath(__DIR__.'/../..');
+
+        if ($hostRoot === false) {
+            throw new RuntimeException('Cannot resolve host Pest root');
+        }
+
+        $composerJson = $path.'/composer.json';
+        $decoded = json_decode((string) file_get_contents($composerJson), true);
+
+        $decoded['repositories'] = [
+            ['type' => 'path', 'url' => $hostRoot, 'options' => ['symlink' => false]],
+        ];
+        $decoded['require']['pestphp/pest'] = '*@dev';
+
+        file_put_contents(
+            $composerJson,
+            json_encode($decoded, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES)."\n",
+        );
+    }
+
+    private static function composerInstall(string $path): void
+    {
+        // Invoke composer via the *same* PHP binary that's running this
+        // process. On macOS multi-version setups (Herd, brew, asdf, etc.)
+        // the `composer` shebang often points at the system PHP, which
+        // may not match the version the test suite booted with — leading
+        // to "your PHP version does not satisfy the requirement" errors
+        // even when the interpreter in use would satisfy it. Going
+        // through `PHP_BINARY` + the located composer binary/phar
+        // sidesteps that entirely.
+        $composer = self::locateComposer();
+        $args = $composer === null
+            ? ['composer', 'install']
+            : [PHP_BINARY, $composer, 'install'];
+
+        $process = new Process(
+            [...$args, '--no-interaction', '--prefer-dist', '--no-progress', '--quiet'],
+            $path,
+        );
+        $process->setTimeout(600.0);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            throw new RuntimeException(
+                "composer install failed in template:\n".$process->getOutput().$process->getErrorOutput(),
+            );
+        }
+    }
+
+    /**
+     * Resolves the composer binary to a real path PHP can execute. Returns
+     * `null` when composer isn't findable, in which case the caller falls
+     * back to invoking plain `composer` via `$PATH` (and hopes for the
+     * best — usually fine on CI Linux runners).
+     */
+    private static function locateComposer(): ?string
+    {
+        $probe = new Process(['command', '-v', 'composer']);
+        $probe->run();
+
+        $path = trim($probe->getOutput());
+
+        if ($path === '' || ! is_file($path)) {
+            return null;
+        }
+
+        // `composer` may be a shell-script wrapper (Herd does this) —
+        // resolve the actual phar it invokes. Heuristic: parse out the
+        // last `.phar` argument from the wrapper, fall back to the file
+        // itself if no wrapper is detected.
+        $content = @file_get_contents($path);
+
+        if ($content !== false && preg_match('/\S+\.phar/', $content, $m) === 1) {
+            $phar = $m[0];
+
+            if (is_file($phar)) {
+                return $phar;
+            }
+        }
+
+        return $path;
+    }
+
+    private static function bootstrapGit(string $path): void
+    {
+        // Each clone needs its own repo — TIA's SHA / branch / diff logic
+        // all rely on `.git/`. The template has no git dir so clones start
+        // from a clean slate.
+        $run = function (array $args) use ($path): void {
+            $process = new Process(['git', ...$args], $path);
+            $process->setTimeout(30.0);
+            $process->run();
+
+            if (! $process->isSuccessful()) {
+                throw new RuntimeException('git '.implode(' ', $args).' failed: '.$process->getErrorOutput());
+            }
+        };
+
+        // `.git` may have been cloned from the template if we ever add one
+        // there — nuke it just in case so every sandbox starts fresh.
+        if (is_dir($path.'/.git')) {
+            self::rrmdir($path.'/.git');
+        }
+
+        // Keep `vendor/` and composer lock out of the sandbox's git repo
+        // entirely. With ~thousands of files `git add .` takes tens of
+        // seconds; TIA also ignores vendor paths via `shouldIgnore()` so
+        // tracking them buys nothing except slowness.
+        file_put_contents($path.'/.gitignore', "vendor/\ncomposer.lock\n");
+
+        $run(['init', '-q', '-b', 'main']);
+        $run(['config', 'user.email', 'sandbox@pest.test']);
+        $run(['config', 'user.name', 'Pest Sandbox']);
+        $run(['config', 'commit.gpgsign', 'false']);
+        $run(['add', '.']);
+        $run(['commit', '-q', '-m', 'initial']);
+    }
+
+    /**
+     * Short hash derived from the host Pest source that the template is
+     * built against. Hashing the newest mtime across `src/`, `overrides/`,
+     * and `composer.json` is cheap (one stat each) and catches every edit
+     * that could alter TIA behaviour.
+     */
+    private static function hostFingerprint(): string
+    {
+        $hostRoot = realpath(__DIR__.'/../..');
+
+        if ($hostRoot === false) {
+            return 'unknown';
+        }
+
+        $newest = 0;
+
+        foreach ([$hostRoot.'/src', $hostRoot.'/overrides'] as $dir) {
+            if (! is_dir($dir)) {
+                continue;
+            }
+
+            $iter = new \RecursiveIteratorIterator(
+                new \RecursiveDirectoryIterator($dir, \FilesystemIterator::SKIP_DOTS),
+            );
+
+            foreach ($iter as $file) {
+                if ($file->isFile()) {
+                    $newest = max($newest, $file->getMTime());
+                }
+            }
+        }
+
+        if (is_file($hostRoot.'/composer.json')) {
+            $newest = max($newest, (int) filemtime($hostRoot.'/composer.json'));
+        }
+
+        return substr(sha1($hostRoot.'|'.PHP_VERSION.'|'.$newest), 0, 12);
+    }
+
+    private static function rcopy(string $src, string $dest): void
+    {
+        if (! is_dir($dest) && ! @mkdir($dest, 0755, true) && ! is_dir($dest)) {
+            throw new RuntimeException("Cannot create {$dest}");
+        }
+
+        $iter = new \RecursiveIteratorIterator(
+            new \RecursiveDirectoryIterator($src, \FilesystemIterator::SKIP_DOTS),
+            \RecursiveIteratorIterator::SELF_FIRST,
+        );
+
+        foreach ($iter as $item) {
+            $target = $dest.DIRECTORY_SEPARATOR.$iter->getSubPathname();
+
+            if ($item->isDir()) {
+                @mkdir($target, 0755, true);
+            } else {
+                copy($item->getPathname(), $target);
+            }
+        }
+    }
+
+    private static function rrmdir(string $dir): void
+    {
+        if (! is_dir($dir)) {
+            return;
+        }
+
+        // `rm -rf` shells out but handles symlinks, read-only files, and
+        // the composer-vendor quirks (lock files, .bin symlinks) that
+        // PHP's own recursive delete stumbles on. Non-fatal on failure.
+        $process = new Process(['rm', '-rf', $dir]);
+        $process->setTimeout(60.0);
+        $process->run();
+    }
+}

tests-tia/bootstrap.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * tests-tia bootstrap.
+ *
+ * Pest's automatic `Pest.php` loader scans the configured `testDirectory()`
+ * which defaults to `tests/` and is hard to override from a nested suite.
+ * So instead of relying on `tests-tia/Pest.php` being found, wire the
+ * helpers in via PHPUnit's explicit `bootstrap=` attribute — simpler,
+ * no config-search surprises.
+ */
+require __DIR__.'/../vendor/autoload.php';
+require __DIR__.'/Support/Sandbox.php';
+
+use Pest\TestsTia\Support\Sandbox;
+use Symfony\Component\Process\Process;
+
+// tests-tia exercises the record path end-to-end, which means the
+// sandbox PHP must expose a coverage driver (pcov or xdebug with
+// coverage mode). Without one, `--tia` records zero edges and every
+// scenario assertion fails with a useless "no coverage driver" banner.
+// Bail out loudly at bootstrap so the failure mode is obvious.
+if (! extension_loaded('pcov') && ! extension_loaded('xdebug')) {
+    fwrite(STDERR, "\n");
+    fwrite(STDERR, "  \e[30;43m SKIP \e[0m tests-tia requires a coverage driver (pcov or xdebug).\n");
+    fwrite(STDERR, "         Install one, then retry:  composer test:tia\n\n");
+
+    // Exit 0 so CI doesn't fail when the driver is genuinely absent —
+    // the CI workflow adds pcov explicitly so this branch only fires on
+    // dev machines that haven't set one up.
+    exit(0);
+}
+
+// Pre-warm the shared composer template once, up-front. Without this,
+// parallel workers race on first use — whoever hits `ensureTemplate()`
+// second gets a half-written template. A file-based lock + single
+// bootstrap pre-warm sidesteps the problem entirely.
+Sandbox::warmTemplate();
+
+/**
+ * Runs `$body` inside a fresh sandbox, guaranteeing teardown even when the
+ * body throws. Keeps scenario tests tidy — one line per setup + destroy.
+ */
+function tiaScenario(Closure $body): void
+{
+    $sandbox = Sandbox::create();
+
+    try {
+        $body($sandbox);
+    } finally {
+        $sandbox->destroy();
+    }
+}
+
+/**
+ * Strip ANSI escapes so assertions are terminal-agnostic.
+ */
+function tiaOutput(Process $process): string
+{
+    $output = $process->getOutput().$process->getErrorOutput();
+
+    return preg_replace('/\e\[[0-9;]*m/', '', $output) ?? $output;
+}

tests-tia/phpunit.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="../vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="bootstrap.php"
+         colors="true"
+         cacheDirectory="../.phpunit.cache/tests-tia"
+         executionOrder="default"
+         failOnRisky="false"
+         failOnWarning="false">
+    <testsuites>
+        <testsuite name="tia">
+            <directory>.</directory>
+            <exclude>Fixtures</exclude>
+            <exclude>Support</exclude>
+        </testsuite>
+    </testsuites>
+</phpunit>

tests/.pest/snapshots/Visual/Help/visual_snapshot_of_help_command_output.snap

@@ -1,5 +1,5 @@
 
-  Pest Testing Framework 4.6.1.  
+  Pest Testing Framework 4.6.3.  
 
   USAGE: pest <file> [options]  
 

tests/.pest/snapshots/Visual/Version/visual_snapshot_of_help_command_output.snap

@@ -1,3 +1,3 @@
 
-  Pest Testing Framework 4.6.1.  
+  Pest Testing Framework 4.6.3.  
 

tests/Arch.php

@@ -37,7 +37,6 @@ arch('contracts')
     ->toOnlyUse([
         'NunoMaduro\Collision\Contracts',
         'Pest\Factories\TestCaseMethodFactory',
-        'Pest\Plugins\Tia\CachedTestResult',
         'Symfony\Component\Console',
         'Pest\Arch\Contracts',
         'Pest\PendingCalls',