feat(tia): continues to work on poc

composer.json

@@ -123,6 +123,7 @@
                 "Pest\\Plugins\\Verbose",
                 "Pest\\Plugins\\Version",
                 "Pest\\Plugins\\Shard",
+                "Pest\\Plugins\\Tia",
                 "Pest\\Plugins\\Parallel"
             ]
         },

src/Bootstrappers/BootSubscribers.php

@@ -25,6 +25,16 @@ final readonly class BootSubscribers implements Bootstrapper
         Subscribers\EnsureIgnorableTestCasesAreIgnored::class,
         Subscribers\EnsureKernelDumpIsFlushed::class,
         Subscribers\EnsureTeamCityEnabled::class,
+        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

@@ -7,12 +7,15 @@ namespace Pest\Concerns;
 use Closure;
 use Pest\Exceptions\DatasetArgumentsMismatch;
 use Pest\Panic;
+use Pest\Plugins\Tia;
 use Pest\Preset;
+use Pest\Support\Container;
 use Pest\Support\ChainableClosure;
 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;
@@ -75,6 +78,12 @@ trait Testable
      */
     public bool $__ran = false;
 
+    /**
+     * Set when a `BeforeEachable` plugin returns a cached success result.
+     * Checked in `__runTest` and `tearDown` to skip body + cleanup.
+     */
+    private bool $__cachedPass = false;
+
     /**
      * The test's test closure.
      */
@@ -227,6 +236,34 @@ trait Testable
     {
         TestSuite::getInstance()->test = $this;
 
+        $this->__cachedPass = false;
+
+        /** @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;
+            }
+
+            // 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');
+        }
+
         $method = TestSuite::getInstance()->tests->get(self::$__filename)->getMethod($this->name());
 
         $description = $method->description;
@@ -302,6 +339,12 @@ trait Testable
      */
     protected function tearDown(...$arguments): void
     {
+        if ($this->__cachedPass) {
+            TestSuite::getInstance()->test = null;
+
+            return;
+        }
+
         $afterEach = TestSuite::getInstance()->afterEach->get(self::$__filename);
 
         if ($this->__afterEach instanceof Closure) {
@@ -327,6 +370,12 @@ trait Testable
      */
     private function __runTest(Closure $closure, ...$args): mixed
     {
+        if ($this->__cachedPass) {
+            $this->addToAssertionCount(1);
+
+            return null;
+        }
+
         $arguments = $this->__resolveTestArguments($args);
         $this->__ensureDatasetArgumentNameAndNumberMatches($arguments);
 

src/Configuration.php

@@ -119,6 +119,14 @@ final readonly class Configuration
         return new Browser\Configuration;
     }
 
+    /**
+     * Gets the TIA (Test Impact Analysis) configuration.
+     */
+    public function tia(): Plugins\Tia\Configuration
+    {
+        return new Plugins\Tia\Configuration;
+    }
+
     /**
      * Proxies calls to the uses method.
      *

src/Kernel.php

@@ -13,6 +13,7 @@ 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;
@@ -64,7 +65,10 @@ final readonly class Kernel
             ->add(TestSuite::class, $testSuite)
             ->add(InputInterface::class, $input)
             ->add(OutputInterface::class, $output)
-            ->add(Container::class, $container);
+            ->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);
 
         $kernel = new self(
             new Application,

src/Plugins/Tia.php

@@ -0,0 +1,865 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins;
+
+use Pest\Contracts\Plugins\AddsOutput;
+use Pest\Contracts\Plugins\HandlesArguments;
+use Pest\Contracts\Plugins\Terminable;
+use PHPUnit\Framework\TestStatus\TestStatus;
+use Pest\Plugins\Tia\ChangedFiles;
+use Pest\Plugins\Tia\Fingerprint;
+use Pest\Plugins\Tia\Graph;
+use Pest\Plugins\Tia\Recorder;
+use Pest\Plugins\Tia\ResultCollector;
+use Pest\Plugins\Tia\WatchPatterns;
+use Pest\Support\Container;
+use Pest\TestSuite;
+use Symfony\Component\Console\Output\OutputInterface;
+use Throwable;
+
+/**
+ * Test Impact Analysis (file-level, parallel-aware).
+ *
+ * Modes
+ * -----
+ *  - **Record** — no graph (or fingerprint / recording commit drifted). The
+ *    full suite runs with PCOV / Xdebug capture per test; the resulting
+ *    `test → [source_file, …]` edges land in `.temp/tia.json`.
+ *  - **Replay** — graph valid. We diff the working tree against the recording
+ *    commit, intersect changed files with graph edges, and run only the
+ *    affected tests. Newly-added tests unknown to the graph are always
+ *    accepted (skipping them would be a correctness hazard).
+ *
+ * Parallel integration
+ * --------------------
+ * This plugin MUST run before `Pest\Plugins\Parallel` in the registered
+ * plugin list — Parallel exits the process as soon as it sees `--parallel`,
+ * so later plugins never get their turn. With the correct order:
+ *
+ *  - **Parent, replay**: narrow the CLI args down to the affected test
+ *    files before Parallel hands them to paratest. Workers then only see
+ *    the narrowed file set and nothing special is required of them.
+ *  - **Parent, record**: flip a global recording flag (via
+ *    `Parallel::setGlobal`) so every spawned worker activates its own
+ *    coverage recorder. The parent does not itself record (paratest runs
+ *    tests in workers); instead we register an `AddsOutput` hook that
+ *    merges per-worker partial graphs after paratest finishes.
+ *  - **Worker, record**: boots through `bin/worker.php`, which re-runs
+ *    `CallsHandleArguments`. We detect the worker context + recording flag,
+ *    activate the `Recorder`, and flush the partial graph on `terminate()`
+ *    into `.temp/tia-worker-<TEST_TOKEN>.json`.
+ *  - **Worker, replay**: nothing to do; args already narrowed.
+ *
+ * Guardrails
+ * ----------
+ *  - `--tia` combined with `--coverage` is refused: both paths drive the
+ *    same coverage driver and would corrupt each other's data.
+ *  - If no coverage driver is available during record, we skip gracefully;
+ *    the suite still runs normally.
+ *  - A stale recording SHA (rebase / force-push) triggers a rebuild.
+ *
+ * @internal
+ */
+final class Tia implements AddsOutput, HandlesArguments, Terminable
+{
+    use Concerns\HandleArguments;
+
+    private const string OPTION = '--tia';
+
+    private const string REBUILD_OPTION = '--tia-rebuild';
+
+    /**
+     * TIA cache lives inside Pest's `.temp/` directory (same location as
+     * PHPUnit's result cache). This directory is gitignored by default in
+     * Pest's own `.gitignore`, so the graph is never committed.
+     */
+    private const string TEMP_DIR = __DIR__
+        .DIRECTORY_SEPARATOR.'..'
+        .DIRECTORY_SEPARATOR.'..'
+        .DIRECTORY_SEPARATOR.'.temp';
+
+    private const string CACHE_FILE = 'tia.json';
+
+    private const string AFFECTED_FILE = 'tia-affected.json';
+
+    private const string WORKER_PREFIX = 'tia-worker-';
+
+    /**
+     * Global flag toggled by the parent process so workers know to record.
+     */
+    private const string RECORDING_GLOBAL = 'TIA_RECORDING';
+
+    /**
+     * Global flag that tells workers to install the TIA filter (replay mode).
+     * Workers read the affected set from `.temp/tia-affected.json`.
+     */
+    private const string REPLAYING_GLOBAL = 'TIA_REPLAYING';
+
+    private bool $graphWritten = false;
+
+    private bool $replayRan = false;
+
+    /**
+     * Counts cache hits during a replay run. Incremented each time
+     * `getCachedResult()` returns a non-null status so the end-of-run
+     * summary reflects what actually happened, not a graph-level estimate.
+     */
+    private int $replayedCount = 0;
+
+    /**
+     * Captured at replay setup so the end-of-run summary can report the
+     * scope of the changes that drove the run.
+     */
+    private int $changedFileCount = 0;
+
+    /**
+     * Captured at replay setup — number of tests the graph flagged as
+     * affected (i.e. should re-execute). May overshoot the actually-
+     * executed count when the user narrows with a path filter.
+     */
+    private int $affectedTestCount = 0;
+
+    /**
+     * Holds the graph during replay so `beforeEach` can look up cached
+     * results without re-loading from disk on every test.
+     */
+    private ?Graph $replayGraph = null;
+
+    /**
+     * Current git branch (or `HEAD` SHA when detached). Resolved once per
+     * run so all graph accesses use the same branch key.
+     */
+    private string $branch = 'main';
+
+    /**
+     * Test files that are affected (should re-execute). Keyed by
+     * project-relative path. Set during `enterReplayMode`.
+     *
+     * @var array<string, true>
+     */
+    private array $affectedFiles = [];
+
+    private static function tempDir(): string
+    {
+        $dir = (string) realpath(self::TEMP_DIR);
+
+        if ($dir === '' || $dir === '.') {
+            // .temp doesn't exist yet — create it.
+            @mkdir(self::TEMP_DIR, 0755, true);
+            $dir = (string) realpath(self::TEMP_DIR);
+        }
+
+        return $dir;
+    }
+
+    private static function cachePath(): string
+    {
+        return self::tempDir().DIRECTORY_SEPARATOR.self::CACHE_FILE;
+    }
+
+    private static function affectedPath(): string
+    {
+        return self::tempDir().DIRECTORY_SEPARATOR.self::AFFECTED_FILE;
+    }
+
+    private static function workerPath(string $token): string
+    {
+        return self::tempDir().DIRECTORY_SEPARATOR.self::WORKER_PREFIX.$token.'.json';
+    }
+
+    private static function workerGlob(): string
+    {
+        return self::tempDir().DIRECTORY_SEPARATOR.self::WORKER_PREFIX.'*.json';
+    }
+
+    public function __construct(
+        private readonly OutputInterface $output,
+        private readonly Recorder $recorder,
+        private readonly WatchPatterns $watchPatterns,
+    ) {}
+
+    /**
+     * Returns the cached result for the given test, or `null` if the test
+     * must run (affected, unknown, or no replay mode active).
+     */
+    public function getCachedResult(string $filename, string $testId): ?TestStatus
+    {
+        if ($this->replayGraph === null) {
+            return null;
+        }
+
+        // Resolve file to project-relative path.
+        $projectRoot = TestSuite::getInstance()->rootPath;
+        $real = @realpath($filename);
+        $rel = $real !== false
+            ? str_replace(DIRECTORY_SEPARATOR, '/', substr($real, strlen(rtrim($projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR)))
+            : null;
+
+        // Affected files must re-execute.
+        if ($rel !== null && isset($this->affectedFiles[$rel])) {
+            return null;
+        }
+
+        // Unknown files (not in graph) must execute — they're new.
+        if ($rel === null || ! $this->replayGraph->knowsTest($rel)) {
+            return null;
+        }
+
+        // Known + unaffected: return cached result if we have one for this
+        // branch (falls back to main if branch is fresh).
+        $result = $this->replayGraph->getResult($this->branch, $testId);
+
+        if ($result !== null) {
+            $this->replayedCount++;
+        }
+
+        return $result;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function handleArguments(array $arguments): array
+    {
+        $isWorker = Parallel::isWorker();
+        $recordingGlobal = $isWorker && (string) Parallel::getGlobal(self::RECORDING_GLOBAL) === '1';
+        $replayingGlobal = $isWorker && (string) Parallel::getGlobal(self::REPLAYING_GLOBAL) === '1';
+
+        $enabled = $this->hasArgument(self::OPTION, $arguments);
+        $forceRebuild = $this->hasArgument(self::REBUILD_OPTION, $arguments);
+
+        if (! $enabled && ! $forceRebuild && ! $recordingGlobal && ! $replayingGlobal) {
+            return $arguments;
+        }
+
+        $arguments = $this->popArgument(self::OPTION, $arguments);
+        $arguments = $this->popArgument(self::REBUILD_OPTION, $arguments);
+
+        if ($this->coverageReportActive()) {
+            if (! $isWorker) {
+                $this->output->writeln(
+                    '  <fg=yellow>TIA</> `--coverage` is active — TIA disabled to avoid '.
+                    'conflicting with PHPUnit\'s own coverage collection.',
+                );
+            }
+
+            return $arguments;
+        }
+
+        $projectRoot = TestSuite::getInstance()->rootPath;
+
+        if ($isWorker) {
+            return $this->handleWorker($arguments, $projectRoot, $recordingGlobal, $replayingGlobal);
+        }
+
+        return $this->handleParent($arguments, $projectRoot, $forceRebuild);
+    }
+
+    public function terminate(): void
+    {
+        if ($this->graphWritten) {
+            return;
+        }
+
+        $recorder = $this->recorder;
+
+        if (! $recorder->isActive()) {
+            return;
+        }
+
+        $this->graphWritten = true;
+
+        $projectRoot = TestSuite::getInstance()->rootPath;
+        $perTest = $recorder->perTestFiles();
+
+        if ($perTest === []) {
+            $recorder->reset();
+
+            return;
+        }
+
+        if (Parallel::isWorker()) {
+            $this->flushWorkerPartial($projectRoot, $perTest);
+            $recorder->reset();
+
+            return;
+        }
+
+        // Non-parallel record path: straight into the main cache.
+        $cachePath = self::cachePath();
+
+        $graph = Graph::load($projectRoot, $cachePath) ?? new Graph($projectRoot);
+        $graph->setFingerprint(Fingerprint::compute($projectRoot));
+        $graph->setRecordedAtSha($this->branch, (new ChangedFiles($projectRoot))->currentSha());
+        $graph->replaceEdges($perTest);
+        $graph->pruneMissingTests();
+
+        if (! $graph->save($cachePath)) {
+            $this->output->writeln('  <fg=red>TIA</> failed to write graph to '.$cachePath);
+            $recorder->reset();
+
+            return;
+        }
+
+        $this->output->writeln(sprintf(
+            '  <fg=green>TIA</> graph recorded (%d test files) at %s',
+            count($perTest),
+            self::CACHE_FILE,
+        ));
+
+        $recorder->reset();
+    }
+
+    /**
+     * Runs after paratest finishes in the parent process. If we were
+     * recording across workers, merge their partial graphs into the main
+     * cache now.
+     */
+    public function addOutput(int $exitCode): int
+    {
+        if (Parallel::isWorker()) {
+            return $exitCode;
+        }
+
+        // After a successful replay run, advance the recorded SHA to HEAD
+        // so the next run only diffs against what changed since NOW, not
+        // since the original recording. Without this, re-running `--tia`
+        // twice in a row would re-execute the same affected tests both
+        // times even though nothing new changed.
+        if ($this->replayRan) {
+            $this->bumpRecordedSha();
+            $this->emitReplaySummary();
+        }
+
+        // Snapshot per-test results (status + message) from PHPUnit's result
+        // cache into our graph so future replay runs can faithfully reproduce
+        // pass/fail/skip/todo/incomplete for unaffected tests.
+        $this->snapshotTestResults();
+
+        if ((string) Parallel::getGlobal(self::RECORDING_GLOBAL) !== '1') {
+            return $exitCode;
+        }
+
+        $projectRoot = TestSuite::getInstance()->rootPath;
+        $partials = $this->collectWorkerPartials($projectRoot);
+
+        if ($partials === []) {
+            return $exitCode;
+        }
+
+        $cachePath = self::cachePath();
+
+        $graph = Graph::load($projectRoot, $cachePath) ?? new Graph($projectRoot);
+        $graph->setFingerprint(Fingerprint::compute($projectRoot));
+        $graph->setRecordedAtSha($this->branch, (new ChangedFiles($projectRoot))->currentSha());
+
+        $merged = [];
+
+        foreach ($partials as $partialPath) {
+            $data = $this->readPartial($partialPath);
+
+            if ($data === null) {
+                continue;
+            }
+
+            foreach ($data as $testFile => $sources) {
+                if (! isset($merged[$testFile])) {
+                    $merged[$testFile] = [];
+                }
+
+                foreach ($sources as $source) {
+                    $merged[$testFile][$source] = true;
+                }
+            }
+
+            @unlink($partialPath);
+        }
+
+        $finalised = [];
+
+        foreach ($merged as $testFile => $sourceSet) {
+            $finalised[$testFile] = array_keys($sourceSet);
+        }
+
+        $graph->replaceEdges($finalised);
+        $graph->pruneMissingTests();
+
+        if (! $graph->save($cachePath)) {
+            $this->output->writeln('  <fg=red>TIA</> failed to write graph to '.$cachePath);
+
+            return $exitCode;
+        }
+
+        $this->output->writeln(sprintf(
+            '  <fg=green>TIA</> graph recorded (%d test files, %d worker partials) at %s',
+            count($finalised),
+            count($partials),
+            self::CACHE_FILE,
+        ));
+
+        return $exitCode;
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function handleParent(array $arguments, string $projectRoot, bool $forceRebuild): array
+    {
+        // Initialise watch patterns (defaults + any user additions from
+        // tests/Pest.php which has already been loaded by BootFiles at
+        // this point).
+        $this->watchPatterns->useDefaults($projectRoot);
+
+        // Resolve current branch once per run so every baseline lookup uses
+        // the same key. Detached HEAD (or no git) falls back to `main` as
+        // the implicit branch identity.
+        $this->branch = (new ChangedFiles($projectRoot))->currentBranch() ?? 'main';
+
+        $cachePath = self::cachePath();
+        $fingerprint = Fingerprint::compute($projectRoot);
+
+        $graph = $forceRebuild ? null : Graph::load($projectRoot, $cachePath);
+
+        if ($graph instanceof Graph && ! Fingerprint::matches($graph->fingerprint(), $fingerprint)) {
+            $this->output->writeln(
+                '  <fg=yellow>TIA</> environment fingerprint changed — graph will be rebuilt.',
+            );
+            $graph = null;
+        }
+
+        if ($graph instanceof Graph) {
+            $changedFiles = new ChangedFiles($projectRoot);
+            $branchSha = $graph->recordedAtSha($this->branch);
+
+            if ($changedFiles->gitAvailable()
+                && $branchSha !== null
+                && $changedFiles->since($branchSha) === null) {
+                $this->output->writeln(
+                    '  <fg=yellow>TIA</> recorded commit is no longer reachable — graph will be rebuilt.',
+                );
+                $graph = null;
+            }
+        }
+
+        if ($graph instanceof Graph) {
+            return $this->enterReplayMode($graph, $projectRoot, $arguments);
+        }
+
+        return $this->enterRecordMode($projectRoot, $arguments);
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function handleWorker(array $arguments, string $projectRoot, bool $recordingGlobal, bool $replayingGlobal): array
+    {
+        $this->branch = (new ChangedFiles($projectRoot))->currentBranch() ?? 'main';
+
+        if ($replayingGlobal) {
+            // Replay in a worker: load the graph and the affected set that
+            // the parent persisted, then install the per-file filter so
+            // whichever tests paratest happens to hand this worker are
+            // accepted / rejected consistently with the series path.
+            $this->installWorkerReplay($projectRoot);
+
+            return $arguments;
+        }
+
+        if (! $recordingGlobal) {
+            return $arguments;
+        }
+
+        $recorder = $this->recorder;
+
+        if (! $recorder->driverAvailable()) {
+            // Driver availability is per-process. If the driver is missing
+            // here, silently skip — the parent has already warned during
+            // its own boot.
+            return $arguments;
+        }
+
+        $recorder->activate();
+
+        return $arguments;
+    }
+
+    /**
+     * Wires worker-side replay. Mirrors the series path: sets `replayGraph`
+     * + `affectedFiles` so the `BeforeEachable` hook in `beforeEach()` can
+     * answer per-test. Unaffected tests replay their cached status (pass,
+     * fail, skip, todo, incomplete) so the user sees the full suite report
+     * in parallel runs exactly like in series.
+     */
+    private function installWorkerReplay(string $projectRoot): void
+    {
+        $cachePath = self::cachePath();
+        $affectedPath = self::affectedPath();
+
+        $graph = Graph::load($projectRoot, $cachePath);
+
+        if (! $graph instanceof Graph) {
+            return;
+        }
+
+        $raw = @file_get_contents($affectedPath);
+
+        if ($raw === false) {
+            return;
+        }
+
+        $decoded = json_decode($raw, true);
+
+        if (! is_array($decoded)) {
+            return;
+        }
+
+        $affectedSet = [];
+
+        foreach ($decoded as $rel) {
+            if (is_string($rel)) {
+                $affectedSet[$rel] = true;
+            }
+        }
+
+        $this->replayGraph = $graph;
+        $this->affectedFiles = $affectedSet;
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function enterReplayMode(Graph $graph, string $projectRoot, array $arguments): array
+    {
+        $changedFiles = new ChangedFiles($projectRoot);
+
+        if (! $changedFiles->gitAvailable()) {
+            $this->output->writeln(
+                '  <fg=yellow>TIA</> git unavailable — running full suite.',
+            );
+
+            return $arguments;
+        }
+
+        $changed = $changedFiles->since($graph->recordedAtSha($this->branch)) ?? [];
+
+        // Drop files whose content hash matches the last-run snapshot. This
+        // is the "dirty but identical" filter: if a file is uncommitted but
+        // its content hasn't moved since the last `--tia` invocation, its
+        // dependents already re-ran last time and don't need re-running
+        // again.
+        $changed = $changedFiles->filterUnchangedSinceLastRun($changed, $graph->lastRunTree($this->branch));
+
+        $affected = $changed === [] ? [] : $graph->affected($changed);
+
+        $this->changedFileCount = count($changed);
+        $this->affectedTestCount = count($affected);
+
+        $affectedSet = array_fill_keys($affected, true);
+
+        $this->replayRan = true;
+        $this->replayGraph = $graph;
+        $this->affectedFiles = $affectedSet;
+
+        if (! Parallel::isEnabled()) {
+            return $arguments;
+        }
+
+        // Parallel: persist affected set so workers can install the filter.
+        if (! $this->persistAffectedSet($projectRoot, $affected)) {
+            $this->output->writeln(
+                '  <fg=red>TIA</> failed to persist affected set — running full suite.',
+            );
+
+            return $arguments;
+        }
+
+        Parallel::setGlobal(self::REPLAYING_GLOBAL, '1');
+
+        return $arguments;
+    }
+
+    /**
+     * @param  array<int, string>  $affected  Project-relative paths.
+     */
+    private function persistAffectedSet(string $projectRoot, array $affected): bool
+    {
+        $path = self::affectedPath();
+        $dir = dirname($path);
+
+        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
+            return false;
+        }
+
+        $json = json_encode(array_values($affected), JSON_UNESCAPED_SLASHES);
+
+        if ($json === false) {
+            return false;
+        }
+
+        $tmp = $path.'.'.bin2hex(random_bytes(4)).'.tmp';
+
+        if (@file_put_contents($tmp, $json) === false) {
+            return false;
+        }
+
+        if (! @rename($tmp, $path)) {
+            @unlink($tmp);
+
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @param  array<int, string>  $arguments
+     * @return array<int, string>
+     */
+    private function enterRecordMode(string $projectRoot, array $arguments): array
+    {
+        if (Parallel::isEnabled()) {
+            // Parent driving `--parallel`: workers will do the actual
+            // recording. We only advertise the intent through a global.
+            // Clean up any stale partial files from a previous interrupted
+            // run so the merge step doesn't confuse itself.
+            $this->purgeWorkerPartials($projectRoot);
+
+            Parallel::setGlobal(self::RECORDING_GLOBAL, '1');
+
+            $this->output->writeln(
+                '  <fg=cyan>TIA</> recording dependency graph in parallel (first run) — '.
+                'subsequent `--tia` runs will only re-execute affected tests.',
+            );
+
+            return $arguments;
+        }
+
+        $recorder = $this->recorder;
+
+        if (! $recorder->driverAvailable()) {
+            $this->output->writeln([
+                '',
+                '  <fg=white;options=bold;bg=red> ERROR </> No coverage driver is available.',
+                '',
+                '  TIA requires ext-pcov or Xdebug with coverage mode enabled to',
+                '  record the dependency graph. Install one and rerun with `--tia`.',
+                '',
+            ]);
+
+            exit(1);
+        }
+
+        $recorder->activate();
+
+        $this->output->writeln(sprintf(
+            '  <fg=cyan>TIA</> recording dependency graph via %s (first run) — '.
+            'subsequent `--tia` runs will only re-execute affected tests.',
+            $recorder->driver(),
+        ));
+
+        return $arguments;
+    }
+
+    /**
+     * @param  array<string, array<int, string>>  $perTest
+     */
+    private function flushWorkerPartial(string $projectRoot, array $perTest): void
+    {
+        $token = $_SERVER['TEST_TOKEN'] ?? $_ENV['TEST_TOKEN'] ?? getmypid();
+        // Defensive: token might arrive as int or string depending on paratest
+        // version. Cast + filter to keep filenames sane.
+        $token = preg_replace('/[^A-Za-z0-9_-]/', '', (string) $token);
+
+        if ($token === '') {
+            $token = (string) getmypid();
+        }
+
+        $path = self::workerPath($token);
+        $dir = dirname($path);
+
+        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
+            return;
+        }
+
+        $json = json_encode($perTest, JSON_UNESCAPED_SLASHES);
+
+        if ($json === false) {
+            return;
+        }
+
+        $tmp = $path.'.'.bin2hex(random_bytes(4)).'.tmp';
+
+        if (@file_put_contents($tmp, $json) === false) {
+            return;
+        }
+
+        if (! @rename($tmp, $path)) {
+            @unlink($tmp);
+        }
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function collectWorkerPartials(string $projectRoot): array
+    {
+        $pattern = self::workerGlob();
+        $matches = glob($pattern);
+
+        return $matches === false ? [] : $matches;
+    }
+
+    private function purgeWorkerPartials(string $projectRoot): void
+    {
+        foreach ($this->collectWorkerPartials($projectRoot) as $path) {
+            @unlink($path);
+        }
+    }
+
+    /**
+     * @return array<string, array<int, string>>|null
+     */
+    private function readPartial(string $path): ?array
+    {
+        $raw = @file_get_contents($path);
+
+        if ($raw === false) {
+            return null;
+        }
+
+        $data = json_decode($raw, true);
+
+        if (! is_array($data)) {
+            return null;
+        }
+
+        $out = [];
+
+        foreach ($data as $test => $sources) {
+            if (! is_string($test)) {
+                continue;
+            }
+            if (! is_array($sources)) {
+                continue;
+            }
+            $clean = [];
+
+            foreach ($sources as $source) {
+                if (is_string($source)) {
+                    $clean[] = $source;
+                }
+            }
+
+            $out[$test] = $clean;
+        }
+
+        return $out;
+    }
+
+    /**
+     * After a successful replay, bump the graph's `recorded_at_sha` to the
+     * current HEAD. This way the next `--tia` run diffs only against what
+     * changed since THIS run, not since the original recording.
+     *
+     * The graph edges themselves are untouched — only the SHA marker moves.
+     */
+    /**
+     * After a successful replay, advance the baseline: bump `recorded_at_sha`
+     * to the current HEAD (handles committed changes) and snapshot the
+     * working tree's content hashes (handles uncommitted changes). Next run
+     * compares against this baseline so identical files are skipped even if
+     * git still reports them as modified.
+     */
+    /**
+     * Prints the post-run TIA summary. Runs after the test report so the
+     * replayed count reflects what actually happened (cache hits counted
+     * inside `getCachedResult`) rather than a graph-level estimate that
+     * ignores any CLI path filter the user passed in.
+     */
+    private function emitReplaySummary(): void
+    {
+        $this->output->writeln(sprintf(
+            '  <fg=green>TIA</> %d changed file(s) → %d affected, %d replayed.',
+            $this->changedFileCount,
+            $this->affectedTestCount,
+            $this->replayedCount,
+        ));
+    }
+
+    private function bumpRecordedSha(): void
+    {
+        $projectRoot = TestSuite::getInstance()->rootPath;
+        $cachePath = self::cachePath();
+
+        $graph = Graph::load($projectRoot, $cachePath);
+
+        if (! $graph instanceof Graph) {
+            return;
+        }
+
+        $changedFiles = new ChangedFiles($projectRoot);
+        $currentSha = $changedFiles->currentSha();
+
+        if ($currentSha !== null) {
+            $graph->setRecordedAtSha($this->branch, $currentSha);
+        }
+
+        // Snapshot the working tree: hash every currently-modified file.
+        // On next run, files still appearing as modified but whose hash
+        // matches this snapshot are treated as unchanged.
+        $workingTreeFiles = $changedFiles->since($currentSha) ?? [];
+        $graph->setLastRunTree($this->branch, $changedFiles->snapshotTree($workingTreeFiles));
+
+        $graph->save($cachePath);
+    }
+
+    /**
+     * Merges per-test status + message from the `ResultCollector` into the
+     * TIA graph. Runs after every `--tia` invocation so the graph always has
+     * fresh results for faithful replay (pass, fail, skip, todo, etc.).
+     */
+    private function snapshotTestResults(): void
+    {
+        /** @var ResultCollector $collector */
+        $collector = Container::getInstance()->get(ResultCollector::class);
+
+        $results = $collector->all();
+
+        if ($results === []) {
+            return;
+        }
+
+        $cachePath = self::cachePath();
+        $projectRoot = TestSuite::getInstance()->rootPath;
+
+        $graph = Graph::load($projectRoot, $cachePath);
+
+        if (! $graph instanceof Graph) {
+            return;
+        }
+
+        foreach ($results as $testId => $result) {
+            $graph->setResult($this->branch, $testId, $result['status'], $result['message'], $result['time']);
+        }
+
+        $graph->save($cachePath);
+        $collector->reset();
+    }
+
+    private function coverageReportActive(): bool
+    {
+        try {
+            /** @var Coverage $coverage */
+            $coverage = Container::getInstance()->get(Coverage::class);
+        } catch (Throwable) {
+            return false;
+        }
+
+        return $coverage->coverage === true;
+    }
+}

src/Plugins/Tia/ChangedFiles.php

@@ -0,0 +1,325 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Symfony\Component\Process\Process;
+
+/**
+ * Detects files that changed between the last recorded TIA run and the
+ * current working tree.
+ *
+ * Strategy:
+ *   1. If we have a `recordedAtSha`, `git diff <sha>..HEAD` captures committed
+ *      changes on top of the recording point.
+ *   2. `git status --short` captures unstaged + staged + untracked changes on
+ *      top of that.
+ *
+ * We return relative paths to the project root. Deletions are included so the
+ * caller can decide whether to invalidate: a deleted source file may still
+ * appear in the graph and should mark its dependents as affected.
+ *
+ * @internal
+ */
+final readonly class ChangedFiles
+{
+    public function __construct(private string $projectRoot) {}
+
+    /**
+     * @return array<int, string>|null `null` when git is unavailable, or when
+     *                                 the recorded SHA is no longer reachable
+     *                                 from HEAD (rebase / force-push) — in
+     *                                 that case the graph should be rebuilt.
+     */
+    /**
+     * Removes files whose current content hash matches the snapshot from the
+     * last `--tia` run. Used to ignore "dirty but unchanged" files — a file
+     * that git still reports as modified but whose content is bit-identical
+     * to the previous TIA invocation.
+     *
+     * @param  array<int, string>  $files          project-relative paths.
+     * @param  array<string, string>  $lastRunTree  path → content hash from last run.
+     * @return array<int, string>
+     */
+    public function filterUnchangedSinceLastRun(array $files, array $lastRunTree): array
+    {
+        if ($lastRunTree === []) {
+            return $files;
+        }
+
+        $remaining = [];
+
+        foreach ($files as $file) {
+            if (! isset($lastRunTree[$file])) {
+                $remaining[] = $file;
+
+                continue;
+            }
+
+            $absolute = $this->projectRoot.DIRECTORY_SEPARATOR.$file;
+
+            if (! is_file($absolute)) {
+                // File is absent now. If the snapshot recorded it as absent
+                // too (sentinel ''), state is identical to last run — treat
+                // as unchanged. Otherwise it was present last run and got
+                // deleted since — that's a real change.
+                if ($lastRunTree[$file] !== '') {
+                    $remaining[] = $file;
+                }
+
+                continue;
+            }
+
+            $hash = @hash_file('xxh128', $absolute);
+
+            if ($hash === false || $hash !== $lastRunTree[$file]) {
+                $remaining[] = $file;
+            }
+        }
+
+        return $remaining;
+    }
+
+    /**
+     * Computes content hashes for the given project-relative files. Used to
+     * snapshot the working tree after a successful run so the next run can
+     * detect which files are actually different.
+     *
+     * @param  array<int, string>  $files
+     * @return array<string, string>  path → xxh128 content hash
+     */
+    public function snapshotTree(array $files): array
+    {
+        $out = [];
+
+        foreach ($files as $file) {
+            $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;
+            }
+
+            $hash = @hash_file('xxh128', $absolute);
+
+            if ($hash !== false) {
+                $out[$file] = $hash;
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * @return array<int, string>|null `null` when git is unavailable, or when
+     *                                 the recorded SHA is no longer reachable
+     *                                 from HEAD (rebase / force-push).
+     */
+    public function since(?string $sha): ?array
+    {
+        if (! $this->gitAvailable()) {
+            return null;
+        }
+
+        $files = [];
+
+        if ($sha !== null && $sha !== '') {
+            if (! $this->shaIsReachable($sha)) {
+                return null;
+            }
+
+            $files = array_merge($files, $this->diffSinceSha($sha));
+        }
+
+        $files = array_merge($files, $this->workingTreeChanges());
+
+        // Normalise + dedupe, filtering out paths that can never belong to the
+        // graph: vendor (caught by the fingerprint instead), cache dirs, and
+        // anything starting with a dot we don't care about.
+        $unique = [];
+
+        foreach ($files as $file) {
+            if ($file === '') {
+                continue;
+            }
+            if ($this->shouldIgnore($file)) {
+                continue;
+            }
+            $unique[$file] = true;
+        }
+
+        return array_keys($unique);
+    }
+
+    private function shouldIgnore(string $path): bool
+    {
+        static $prefixes = [
+            '.pest/',
+            '.phpunit.cache/',
+            '.phpunit.result.cache',
+            'vendor/',
+            'node_modules/',
+        ];
+
+        foreach ($prefixes as $prefix) {
+            if (str_starts_with($path, (string) $prefix)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public function currentBranch(): ?string
+    {
+        if (! $this->gitAvailable()) {
+            return null;
+        }
+
+        $process = new Process(['git', 'rev-parse', '--abbrev-ref', 'HEAD'], $this->projectRoot);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        $branch = trim($process->getOutput());
+
+        return $branch === '' || $branch === 'HEAD' ? null : $branch;
+    }
+
+    public function gitAvailable(): bool
+    {
+        $process = new Process(['git', 'rev-parse', '--git-dir'], $this->projectRoot);
+        $process->run();
+
+        return $process->isSuccessful();
+    }
+
+    private function shaIsReachable(string $sha): bool
+    {
+        $process = new Process(
+            ['git', 'merge-base', '--is-ancestor', $sha, 'HEAD'],
+            $this->projectRoot,
+        );
+        $process->run();
+
+        // Exit 0 → ancestor; 1 → not ancestor; anything else → git error
+        // (e.g. unknown commit after a rebase/gc). Treat non-zero as
+        // "unreachable" and force a rebuild.
+        return $process->getExitCode() === 0;
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function diffSinceSha(string $sha): array
+    {
+        $process = new Process(
+            ['git', 'diff', '--name-only', $sha.'..HEAD'],
+            $this->projectRoot,
+        );
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return [];
+        }
+
+        return $this->splitLines($process->getOutput());
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function workingTreeChanges(): array
+    {
+        // `-z` produces NUL-terminated records with no path quoting, so paths
+        // that contain spaces, tabs, unicode or other special characters
+        // are passed through verbatim. Without `-z`, git wraps such paths in
+        // quotes with backslash escapes, which would corrupt our lookup keys.
+        //
+        // Record format: `XY <SP> <path> <NUL>` for most entries, and
+        // `R  <new> <NUL> <orig> <NUL>` for renames/copies (two NUL-separated
+        // fields).
+        $process = new Process(
+            ['git', 'status', '--porcelain', '-z', '--untracked-files=all'],
+            $this->projectRoot,
+        );
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return [];
+        }
+
+        $output = $process->getOutput();
+
+        if ($output === '') {
+            return [];
+        }
+
+        $records = explode("\x00", rtrim($output, "\x00"));
+        $files = [];
+        $count = count($records);
+
+        for ($i = 0; $i < $count; $i++) {
+            $record = $records[$i];
+
+            if (strlen($record) < 4) {
+                continue;
+            }
+
+            $status = substr($record, 0, 2);
+            $path = substr($record, 3);
+
+            // Renames/copies emit two records: the new path first, then the
+            // original. Consume both.
+            if ($status[0] === 'R' || $status[0] === 'C') {
+                $files[] = $path;
+
+                if (isset($records[$i + 1]) && $records[$i + 1] !== '') {
+                    $files[] = $records[$i + 1];
+                    $i++;
+                }
+
+                continue;
+            }
+
+            $files[] = $path;
+        }
+
+        return $files;
+    }
+
+    public function currentSha(): ?string
+    {
+        if (! $this->gitAvailable()) {
+            return null;
+        }
+
+        $process = new Process(['git', 'rev-parse', 'HEAD'], $this->projectRoot);
+        $process->run();
+
+        if (! $process->isSuccessful()) {
+            return null;
+        }
+
+        $sha = trim($process->getOutput());
+
+        return $sha === '' ? null : $sha;
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function splitLines(string $output): array
+    {
+        $lines = preg_split('/\R+/', trim($output), flags: PREG_SPLIT_NO_EMPTY);
+
+        return $lines === false ? [] : $lines;
+    }
+}

src/Plugins/Tia/Configuration.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Support\Container;
+
+/**
+ * User-facing TIA configuration, returned by `pest()->tia()`.
+ *
+ * Usage in `tests/Pest.php`:
+ *
+ *     pest()->tia()->watch([
+ *         'resources/js/**\/*.tsx' => 'tests/Browser',
+ *         'public/build/**\/*'     => 'tests/Browser',
+ *     ]);
+ *
+ * Patterns are merged with the built-in defaults (config, routes, views,
+ * frontend assets, migrations). Duplicate glob keys overwrite the default
+ * mapping so users can redirect a pattern to a narrower directory.
+ *
+ * @internal
+ */
+final class Configuration
+{
+    /**
+     * Adds watch-pattern → test-directory mappings that supplement (or
+     * override) the built-in defaults.
+     *
+     * @param  array<string, string>  $patterns  glob → project-relative test dir
+     * @return $this
+     */
+    public function watch(array $patterns): self
+    {
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+        $watchPatterns->add($patterns);
+
+        return $this;
+    }
+}

src/Plugins/Tia/Fingerprint.php

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+/**
+ * Captures environmental inputs that, when changed, make the TIA graph stale.
+ *
+ * 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.
+ *
+ * @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;
+
+    /**
+     * @return array<string, int|string|null>
+     */
+    public static function compute(string $projectRoot): array
+    {
+        return [
+            '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_factory' => self::hashIfExists(__DIR__.'/../../Factories/TestCaseFactory.php'),
+            'pest_method_factory' => self::hashIfExists(__DIR__.'/../../Factories/TestCaseMethodFactory.php'),
+        ];
+    }
+
+    /**
+     * @param  array<string, mixed>  $a
+     * @param  array<string, mixed>  $b
+     */
+    public static function matches(array $a, array $b): bool
+    {
+        ksort($a);
+        ksort($b);
+
+        return $a === $b;
+    }
+
+    private static function hashIfExists(string $path): ?string
+    {
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $hash = @hash_file('xxh128', $path);
+
+        return $hash === false ? null : $hash;
+    }
+
+    private static function readPestVersion(string $projectRoot): string
+    {
+        $installed = $projectRoot.'/vendor/composer/installed.json';
+
+        if (! is_file($installed)) {
+            return 'unknown';
+        }
+
+        $raw = @file_get_contents($installed);
+
+        if ($raw === false) {
+            return 'unknown';
+        }
+
+        $data = json_decode($raw, true);
+
+        if (! is_array($data) || ! isset($data['packages']) || ! is_array($data['packages'])) {
+            return 'unknown';
+        }
+
+        foreach ($data['packages'] as $package) {
+            if (is_array($package) && ($package['name'] ?? null) === 'pestphp/pest') {
+                return (string) ($package['version'] ?? 'unknown');
+            }
+        }
+
+        return 'unknown';
+    }
+}

src/Plugins/Tia/Graph.php

@@ -0,0 +1,500 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Support\Container;
+use PHPUnit\Framework\TestStatus\TestStatus;
+
+/**
+ * File-level Test Impact Analysis graph.
+ *
+ * Persists the mapping `test_file → set<source_file>` so that subsequent runs
+ * can skip tests whose dependencies have not changed. Paths are stored relative
+ * to the project root and source files are deduplicated via an index so that
+ * the on-disk JSON stays compact for large suites.
+ *
+ * @internal
+ */
+final class Graph
+{
+    /**
+     * Relative path of each known source file, indexed by numeric id.
+     *
+     * @var array<int, string>
+     */
+    private array $files = [];
+
+    /**
+     * Reverse lookup: source file → numeric id.
+     *
+     * @var array<string, int>
+     */
+    private array $fileIds = [];
+
+    /**
+     * Edges: test file (relative) → list of source file ids.
+     *
+     * @var array<string, array<int, int>>
+     */
+    private array $edges = [];
+
+    /**
+     * Environment fingerprint captured at record time.
+     *
+     * @var array<string, mixed>
+     */
+    private array $fingerprint = [];
+
+    /**
+     * Per-branch baselines. Each branch independently tracks:
+     *   - `sha`     — last HEAD at which `--tia` ran on this branch
+     *   - `tree`    — content hashes of modified files at that point
+     *   - `results` — per-test status + message + time
+     *
+     * Graph edges (test → source) stay shared across branches because
+     * structure doesn't change per branch. Only run-state is per-branch so
+     * a failing test on one branch doesn't poison another branch's replay.
+     *
+     * @var array<string, array{
+     *     sha: ?string,
+     *     tree: array<string, string>,
+     *     results: array<string, array{status: int, message: string, time: float}>
+     * }>
+     */
+    private array $baselines = [];
+
+    /**
+     * Canonicalised project root. Resolved through `realpath()` so paths
+     * captured by coverage drivers (always real filesystem targets) match
+     * regardless of whether the user's CWD is a symlink or has trailing
+     * separators.
+     */
+    private readonly string $projectRoot;
+
+    public function __construct(string $projectRoot)
+    {
+        $real = @realpath($projectRoot);
+
+        $this->projectRoot = $real !== false ? $real : $projectRoot;
+    }
+
+    /**
+     * Records that a test file depends on the given source file.
+     */
+    public function link(string $testFile, string $sourceFile): void
+    {
+        $testRel = $this->relative($testFile);
+        $sourceRel = $this->relative($sourceFile);
+
+        if ($sourceRel === null || $testRel === null) {
+            return;
+        }
+
+        if (! isset($this->fileIds[$sourceRel])) {
+            $id = count($this->files);
+            $this->files[$id] = $sourceRel;
+            $this->fileIds[$sourceRel] = $id;
+        }
+
+        $this->edges[$testRel][] = $this->fileIds[$sourceRel];
+    }
+
+    /**
+     * Returns the set of test files whose dependencies intersect $changedFiles.
+     *
+     * Two resolution paths:
+     *   1. **Coverage edges** — test depends on a PHP source file that changed.
+     *   2. **Watch patterns** — a non-PHP file (JS, CSS, config, …) matches a
+     *      glob that maps to a test directory; every test under that directory
+     *      is affected.
+     *
+     * @param  array<int, string>  $changedFiles  Absolute or relative paths.
+     * @return array<int, string> Relative test file paths.
+     */
+    public function affected(array $changedFiles): array
+    {
+        // Normalise all changed paths once.
+        $normalised = [];
+
+        foreach ($changedFiles as $file) {
+            $rel = $this->relative($file);
+
+            if ($rel !== null) {
+                $normalised[] = $rel;
+            }
+        }
+
+        // 1. Coverage-edge lookup (PHP → PHP).
+        $changedIds = [];
+        $unknownSourceDirs = [];
+
+        foreach ($normalised as $rel) {
+            if (isset($this->fileIds[$rel])) {
+                $changedIds[$this->fileIds[$rel]] = true;
+            } elseif (str_ends_with($rel, '.php') && ! str_starts_with($rel, 'tests/')) {
+                // Source PHP file unknown to the graph — might be a new file
+                // that only exists on this branch (graph inherited from main).
+                // Track its directory for the sibling heuristic (step 3).
+                $unknownSourceDirs[dirname($rel)] = true;
+            }
+        }
+
+        $affectedSet = [];
+
+        foreach ($this->edges as $testFile => $ids) {
+            foreach ($ids as $id) {
+                if (isset($changedIds[$id])) {
+                    $affectedSet[$testFile] = true;
+
+                    break;
+                }
+            }
+        }
+
+        // 2. Watch-pattern lookup (non-PHP assets → test directories).
+        /** @var WatchPatterns $watchPatterns */
+        $watchPatterns = Container::getInstance()->get(WatchPatterns::class);
+
+        $dirs = $watchPatterns->matchedDirectories($this->projectRoot, $normalised);
+        $allTestFiles = array_keys($this->edges);
+
+        foreach ($watchPatterns->testsUnderDirectories($dirs, $allTestFiles) as $testFile) {
+            $affectedSet[$testFile] = true;
+        }
+
+        // 3. Sibling heuristic for unknown source files.
+        //
+        // When a PHP source file is unknown to the graph (no test depends on
+        // it), it is either genuinely untested OR it was added on a branch
+        // whose graph was inherited from another branch (e.g. main). In the
+        // latter case the graph simply never saw the file.
+        //
+        // To avoid silent misses: find tests that already cover ANY file in
+        // the same directory. If `app/Models/OrderItem.php` is unknown but
+        // `app/Models/Order.php` is covered by `OrderTest`, run `OrderTest`
+        // — it likely exercises sibling files in the same module.
+        //
+        // This over-runs slightly (sibling may be unrelated) but never
+        // under-runs. And once the test executes, its coverage captures the
+        // new file → graph self-heals for next run.
+        if ($unknownSourceDirs !== []) {
+            foreach ($this->edges as $testFile => $ids) {
+                if (isset($affectedSet[$testFile])) {
+                    continue;
+                }
+
+                foreach ($ids as $id) {
+                    if (! isset($this->files[$id])) {
+                        continue;
+                    }
+
+                    $depDir = dirname($this->files[$id]);
+
+                    if (isset($unknownSourceDirs[$depDir])) {
+                        $affectedSet[$testFile] = true;
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        return array_keys($affectedSet);
+    }
+
+    /**
+     * Returns `true` if the given test file has any recorded dependencies.
+     */
+    public function knowsTest(string $testFile): bool
+    {
+        $rel = $this->relative($testFile);
+
+        return $rel !== null && isset($this->edges[$rel]);
+    }
+
+    /**
+     * @return array<int, string> All project-relative test files the graph knows.
+     */
+    public function allTestFiles(): array
+    {
+        return array_keys($this->edges);
+    }
+
+    /**
+     * @param  array<string, int|string|null>  $fingerprint
+     */
+    public function setFingerprint(array $fingerprint): void
+    {
+        $this->fingerprint = $fingerprint;
+    }
+
+    /**
+     * @return array<string, int|string|null>
+     */
+    public function fingerprint(): array
+    {
+        return $this->fingerprint;
+    }
+
+    /**
+     * Returns the SHA the given branch last ran against, or falls back to
+     * `$fallbackBranch` (typically `main`) when this branch has no baseline
+     * yet. That way a freshly-created feature branch inherits main's
+     * baseline on its first run.
+     */
+    public function recordedAtSha(string $branch, string $fallbackBranch = 'main'): ?string
+    {
+        $baseline = $this->baselineFor($branch, $fallbackBranch);
+
+        return $baseline['sha'];
+    }
+
+    public function setRecordedAtSha(string $branch, ?string $sha): void
+    {
+        $this->ensureBaseline($branch);
+        $this->baselines[$branch]['sha'] = $sha;
+    }
+
+    public function setResult(string $branch, string $testId, int $status, string $message, float $time): void
+    {
+        $this->ensureBaseline($branch);
+        $this->baselines[$branch]['results'][$testId] = [
+            'status' => $status, 'message' => $message, 'time' => $time,
+        ];
+    }
+
+    public function getResult(string $branch, string $testId, string $fallbackBranch = 'main'): ?TestStatus
+    {
+        $baseline = $this->baselineFor($branch, $fallbackBranch);
+
+        if (! isset($baseline['results'][$testId])) {
+            return null;
+        }
+
+        $r = $baseline['results'][$testId];
+
+        // 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(),
+        };
+    }
+
+    /**
+     * @param  array<string, string>  $tree  project-relative path → content hash
+     */
+    public function setLastRunTree(string $branch, array $tree): void
+    {
+        $this->ensureBaseline($branch);
+        $this->baselines[$branch]['tree'] = $tree;
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function lastRunTree(string $branch, string $fallbackBranch = 'main'): array
+    {
+        return $this->baselineFor($branch, $fallbackBranch)['tree'];
+    }
+
+    /**
+     * @return array{sha: ?string, tree: array<string, string>, results: array<string, array{status: int, message: string, time: float}>}
+     */
+    private function baselineFor(string $branch, string $fallbackBranch): array
+    {
+        if (isset($this->baselines[$branch])) {
+            return $this->baselines[$branch];
+        }
+
+        if ($branch !== $fallbackBranch && isset($this->baselines[$fallbackBranch])) {
+            return $this->baselines[$fallbackBranch];
+        }
+
+        return ['sha' => null, 'tree' => [], 'results' => []];
+    }
+
+    private function ensureBaseline(string $branch): void
+    {
+        if (! isset($this->baselines[$branch])) {
+            $this->baselines[$branch] = ['sha' => null, 'tree' => [], 'results' => []];
+        }
+    }
+
+    /**
+     * Replaces edges for the given test files. Used during a partial record
+     * run so that existing edges for other tests are preserved.
+     *
+     * @param  array<string, array<int, string>>  $testToFiles
+     */
+    public function replaceEdges(array $testToFiles): void
+    {
+        foreach ($testToFiles as $testFile => $sources) {
+            $testRel = $this->relative($testFile);
+
+            if ($testRel === null) {
+                continue;
+            }
+
+            $this->edges[$testRel] = [];
+
+            foreach ($sources as $source) {
+                $this->link($testFile, $source);
+            }
+
+            // Deduplicate ids for this test.
+            $this->edges[$testRel] = array_values(array_unique($this->edges[$testRel]));
+        }
+    }
+
+    /**
+     * Drops edges whose test file no longer exists on disk. Prevents the graph
+     * from keeping stale entries for deleted / renamed tests that would later
+     * be flagged as affected and confuse PHPUnit's discovery.
+     */
+    public function pruneMissingTests(): void
+    {
+        $root = rtrim($this->projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+
+        foreach (array_keys($this->edges) as $testRel) {
+            if (! is_file($root.$testRel)) {
+                unset($this->edges[$testRel]);
+            }
+        }
+    }
+
+    public static function load(string $projectRoot, string $path): ?self
+    {
+        if (! is_file($path)) {
+            return null;
+        }
+
+        $raw = @file_get_contents($path);
+
+        if ($raw === false) {
+            return null;
+        }
+
+        $data = json_decode($raw, true);
+
+        if (! is_array($data) || ($data['schema'] ?? null) !== 1) {
+            return null;
+        }
+
+        $graph = new self($projectRoot);
+        $graph->fingerprint = is_array($data['fingerprint'] ?? null) ? $data['fingerprint'] : [];
+        $graph->files = is_array($data['files'] ?? null) ? array_values($data['files']) : [];
+        $graph->fileIds = array_flip($graph->files);
+        $graph->edges = is_array($data['edges'] ?? null) ? $data['edges'] : [];
+        $graph->baselines = is_array($data['baselines'] ?? null) ? $data['baselines'] : [];
+
+        return $graph;
+    }
+
+    public function save(string $path): bool
+    {
+        $dir = dirname($path);
+
+        if (! is_dir($dir) && ! @mkdir($dir, 0755, true) && ! is_dir($dir)) {
+            return false;
+        }
+
+        $payload = [
+            'schema' => 1,
+            'fingerprint' => $this->fingerprint,
+            'files' => $this->files,
+            'edges' => $this->edges,
+            '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;
+    }
+
+    /**
+     * Normalises a path to be relative to the project root; returns `null` for
+     * paths we should ignore (outside the project, unknown, virtual, vendor).
+     *
+     * Accepts both absolute paths (from Xdebug/PCOV coverage) and
+     * project-relative paths (from `git diff`) — we normalise without relying
+     * on `realpath()` of relative paths because the current working directory
+     * is not guaranteed to be the project root.
+     */
+    private function relative(string $path): ?string
+    {
+        if ($path === '' || $path === 'unknown') {
+            return null;
+        }
+
+        if (str_contains($path, "eval()'d")) {
+            return null;
+        }
+
+        $root = rtrim($this->projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+
+        $isAbsolute = str_starts_with($path, DIRECTORY_SEPARATOR)
+            || (strlen($path) >= 2 && $path[1] === ':'); // Windows drive
+
+        if ($isAbsolute) {
+            $real = @realpath($path);
+
+            if ($real === false) {
+                $real = $path;
+            }
+
+            if (! str_starts_with($real, $root)) {
+                return null;
+            }
+
+            // Always normalise to forward slashes. Windows' native separator
+            // would otherwise produce keys that never match paths reported
+            // by `git` (which always uses forward slashes).
+            $relative = str_replace(DIRECTORY_SEPARATOR, '/', substr($real, strlen($root)));
+        } else {
+            // Normalise directory separators and strip any "./" prefix.
+            $relative = str_replace(DIRECTORY_SEPARATOR, '/', $path);
+
+            while (str_starts_with($relative, './')) {
+                $relative = substr($relative, 2);
+            }
+        }
+
+        // Vendor packages are pinned by composer.lock. Any upgrade bumps the
+        // fingerprint and invalidates the graph wholesale, so there is no
+        // reason to track individual vendor files — doing so inflates the
+        // graph by orders of magnitude on Laravel-style projects.
+        if (str_starts_with($relative, 'vendor/')) {
+            return null;
+        }
+
+        return $relative;
+    }
+}

src/Plugins/Tia/Recorder.php

@@ -0,0 +1,229 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use ReflectionClass;
+
+/**
+ * Captures per-test file coverage using the PCOV driver.
+ *
+ * Acts as a singleton because PCOV has a single global collection state and
+ * the recorder is wired into PHPUnit through two distinct subscribers
+ * (`Prepared` / `Finished`) that must share context.
+ *
+ * @internal
+ */
+final class Recorder
+{
+    /**
+     * Test file currently being recorded, or `null` when idle.
+     */
+    private ?string $currentTestFile = null;
+
+    /**
+     * Aggregated map: absolute test file → set<absolute source file>.
+     *
+     * @var array<string, array<string, true>>
+     */
+    private array $perTestFiles = [];
+
+    /**
+     * Cached class → test file resolution.
+     *
+     * @var array<string, string|null>
+     */
+    private array $classFileCache = [];
+
+    private bool $active = false;
+
+    private bool $driverChecked = false;
+
+    private bool $driverAvailable = false;
+
+    private string $driver = 'none';
+
+    public function activate(): void
+    {
+        $this->active = true;
+    }
+
+    public function isActive(): bool
+    {
+        return $this->active;
+    }
+
+    public function driverAvailable(): bool
+    {
+        if (! $this->driverChecked) {
+            if (function_exists('pcov\\start')) {
+                $this->driver = 'pcov';
+                $this->driverAvailable = true;
+            } elseif (function_exists('xdebug_start_code_coverage')) {
+                // Xdebug is loaded. Probe whether coverage mode is active by
+                // attempting a start — it emits E_WARNING when the mode is off.
+                // We capture the warning via a temporary error handler.
+                $probeOk = true;
+                set_error_handler(static function () use (&$probeOk): bool {
+                    $probeOk = false;
+
+                    return true;
+                });
+                \xdebug_start_code_coverage();
+                restore_error_handler();
+
+                if ($probeOk) {
+                    \xdebug_stop_code_coverage(false);
+                    $this->driver = 'xdebug';
+                    $this->driverAvailable = true;
+                }
+            }
+
+            $this->driverChecked = true;
+        }
+
+        return $this->driverAvailable;
+    }
+
+    public function driver(): string
+    {
+        $this->driverAvailable();
+
+        return $this->driver;
+    }
+
+    public function beginTest(string $className, string $methodName, string $fallbackFile): void
+    {
+        if (! $this->active || ! $this->driverAvailable()) {
+            return;
+        }
+
+        $file = $this->resolveTestFile($className, $fallbackFile);
+
+        if ($file === null) {
+            return;
+        }
+
+        $this->currentTestFile = $file;
+
+        if ($this->driver === 'pcov') {
+            \pcov\clear();
+            \pcov\start();
+
+            return;
+        }
+
+        // Xdebug
+        \xdebug_start_code_coverage();
+    }
+
+    public function endTest(): void
+    {
+        if (! $this->active || ! $this->driverAvailable() || $this->currentTestFile === null) {
+            return;
+        }
+
+        if ($this->driver === 'pcov') {
+            \pcov\stop();
+            /** @var array<string, mixed> $data */
+            $data = \pcov\collect(\pcov\inclusive);
+        } else {
+            /** @var array<string, mixed> $data */
+            $data = \xdebug_get_code_coverage();
+            // `true` resets Xdebug's internal buffer so the next `start()`
+            // does not accumulate earlier tests' coverage into the current
+            // one — otherwise the graph becomes progressively polluted.
+            \xdebug_stop_code_coverage(true);
+        }
+
+        foreach (array_keys($data) as $sourceFile) {
+            $this->perTestFiles[$this->currentTestFile][$sourceFile] = true;
+        }
+
+        $this->currentTestFile = null;
+    }
+
+    /**
+     * @return array<string, array<int, string>> absolute test file → list of absolute source files.
+     */
+    public function perTestFiles(): array
+    {
+        $out = [];
+
+        foreach ($this->perTestFiles as $testFile => $sources) {
+            $out[$testFile] = array_keys($sources);
+        }
+
+        return $out;
+    }
+
+    private function resolveTestFile(string $className, string $fallbackFile): ?string
+    {
+        if (array_key_exists($className, $this->classFileCache)) {
+            $file = $this->classFileCache[$className];
+        } else {
+            $file = $this->readPestFilename($className);
+            $this->classFileCache[$className] = $file;
+        }
+
+        if ($file !== null) {
+            return $file;
+        }
+
+        if ($fallbackFile !== '' && $fallbackFile !== 'unknown' && ! str_contains($fallbackFile, "eval()'d")) {
+            return $fallbackFile;
+        }
+
+        return null;
+    }
+
+    /**
+     * Resolves the file that *defines* the test class.
+     *
+     * Order of preference:
+     *   1. Pest's generated `$__filename` static — the original `*.php` file
+     *      containing the `test()` calls (the eval'd class itself has no file).
+     *   2. `ReflectionClass::getFileName()` — the concrete class's file. This
+     *      is intentionally more specific than `ReflectionMethod::getFileName()`
+     *      (which would return the *trait* file for methods brought in via
+     *      `uses SharedTestBehavior`).
+     */
+    private function readPestFilename(string $className): ?string
+    {
+        if (! class_exists($className, false)) {
+            return null;
+        }
+
+        $reflection = new ReflectionClass($className);
+
+        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;
+    }
+
+    /**
+     * Clears all captured state. Useful for long-running hosts (daemons,
+     * PHP-FPM, watchers) that invoke Pest multiple times in a single process
+     * — without this, coverage from run N would bleed into run N+1.
+     */
+    public function reset(): void
+    {
+        $this->currentTestFile = null;
+        $this->perTestFiles = [];
+        $this->classFileCache = [];
+        $this->active = false;
+    }
+}

src/Plugins/Tia/ResultCollector.php

@@ -0,0 +1,127 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+/**
+ * Collects per-test status + message during the run so the graph can persist
+ * them for faithful replay. PHPUnit's own result cache discards messages
+ * during serialisation — this collector retains them.
+ *
+ * @internal
+ */
+final class ResultCollector
+{
+    /**
+     * @var array<string, array{status: int, message: string, time: float, assertions: int}>
+     */
+    private array $results = [];
+
+    private ?string $currentTestId = null;
+
+    private ?float $startTime = null;
+
+    public function testPrepared(string $testId): void
+    {
+        $this->currentTestId = $testId;
+        $this->startTime = microtime(true);
+    }
+
+    public function testPassed(): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(0, '');
+    }
+
+    public function testFailed(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(7, $message);
+    }
+
+    public function testErrored(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(8, $message);
+    }
+
+    public function testSkipped(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(1, $message);
+    }
+
+    public function testIncomplete(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(2, $message);
+    }
+
+    public function testRisky(string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $this->record(5, $message);
+    }
+
+    /**
+     * @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;
+        }
+    }
+
+    public function reset(): void
+    {
+        $this->results = [];
+        $this->currentTestId = null;
+        $this->startTime = null;
+    }
+
+    private function record(int $status, string $message): void
+    {
+        if ($this->currentTestId === null) {
+            return;
+        }
+
+        $time = $this->startTime !== null
+            ? round(microtime(true) - $this->startTime, 3)
+            : 0.0;
+
+        $this->results[$this->currentTestId] = [
+            'status' => $status,
+            'message' => $message,
+            'time' => $time,
+            'assertions' => 0,
+        ];
+
+        $this->currentTestId = null;
+        $this->startTime = null;
+    }
+}

src/Plugins/Tia/WatchDefaults/Browser.php

@@ -0,0 +1,119 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+use Pest\Browser\Support\BrowserTestIdentifier;
+use Pest\Factories\TestCaseFactory;
+use Pest\TestSuite;
+
+/**
+ * Watch patterns for frontend assets that affect browser tests.
+ *
+ * Uses `BrowserTestIdentifier` from pest-plugin-browser (if installed) to
+ * auto-discover directories containing browser tests. Falls back to the
+ * `tests/Browser` convention when the plugin is absent.
+ *
+ * @internal
+ */
+final readonly class Browser implements WatchDefault
+{
+    public function applicable(): bool
+    {
+        // Browser tests can exist in any PHP project. We only activate when
+        // there is an actual `tests/Browser` directory OR pest-plugin-browser
+        // is installed.
+        return class_exists(InstalledVersions::class)
+            && InstalledVersions::isInstalled('pestphp/pest-plugin-browser');
+    }
+
+    public function defaults(string $projectRoot, string $testPath): array
+    {
+        $browserDirs = $this->detectBrowserTestDirs($projectRoot, $testPath);
+
+        $globs = [
+            'resources/js/**/*.js',
+            'resources/js/**/*.ts',
+            'resources/js/**/*.tsx',
+            'resources/js/**/*.jsx',
+            'resources/js/**/*.vue',
+            'resources/js/**/*.svelte',
+            'resources/css/**/*.css',
+            'resources/css/**/*.scss',
+            'resources/css/**/*.less',
+            // Vite / Webpack build output that browser tests may consume.
+            'public/build/**/*.js',
+            'public/build/**/*.css',
+        ];
+
+        $patterns = [];
+
+        foreach ($globs as $glob) {
+            $patterns[$glob] = $browserDirs;
+        }
+
+        return $patterns;
+    }
+
+    /**
+     * @return array<int, string>
+     */
+    private function detectBrowserTestDirs(string $projectRoot, string $testPath): array
+    {
+        $dirs = [];
+
+        $candidate = $testPath.'/Browser';
+
+        if (is_dir($projectRoot.DIRECTORY_SEPARATOR.$candidate)) {
+            $dirs[] = $candidate;
+        }
+
+        // Scan TestRepository via BrowserTestIdentifier if pest-plugin-browser
+        // is installed to find tests using `visit()` outside the conventional
+        // Browser/ folder.
+        if (class_exists(BrowserTestIdentifier::class)) {
+            $repo = TestSuite::getInstance()->tests;
+
+            foreach ($repo->getFilenames() as $filename) {
+                $factory = $repo->get($filename);
+
+                if (! $factory instanceof TestCaseFactory) {
+                    continue;
+                }
+
+                foreach ($factory->methods as $method) {
+                    if (BrowserTestIdentifier::isBrowserTest($method)) {
+                        $rel = $this->fileRelative($projectRoot, $filename);
+
+                        if ($rel !== null) {
+                            $dirs[] = dirname($rel);
+                        }
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        return array_values(array_unique($dirs === [] ? [$testPath] : $dirs));
+    }
+
+    private function fileRelative(string $projectRoot, string $path): ?string
+    {
+        $real = @realpath($path);
+
+        if ($real === false) {
+            $real = $path;
+        }
+
+        $root = rtrim($projectRoot, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
+
+        if (! str_starts_with($real, $root)) {
+            return null;
+        }
+
+        return str_replace(DIRECTORY_SEPARATOR, '/', substr($real, strlen($root)));
+    }
+}

src/Plugins/Tia/WatchDefaults/Inertia.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+
+/**
+ * Watch patterns for Inertia.js projects (Laravel or otherwise).
+ *
+ * Inertia bridges PHP controllers with JS/TS page components. A change to
+ * a React / Vue / Svelte page can break assertions in browser tests or
+ * Inertia-specific feature tests.
+ *
+ * @internal
+ */
+final readonly class Inertia implements WatchDefault
+{
+    public function applicable(): bool
+    {
+        return class_exists(InstalledVersions::class)
+            && (InstalledVersions::isInstalled('inertiajs/inertia-laravel')
+                || InstalledVersions::isInstalled('rompetomp/inertia-bundle'));
+    }
+
+    public function defaults(string $projectRoot, string $testPath): array
+    {
+        $browserDir = is_dir($projectRoot.DIRECTORY_SEPARATOR.$testPath.'/Browser')
+            ? $testPath.'/Browser'
+            : $testPath;
+
+        return [
+            // Inertia page components (React / Vue / Svelte).
+            'resources/js/Pages/**/*.vue' => [$testPath, $browserDir],
+            'resources/js/Pages/**/*.tsx' => [$testPath, $browserDir],
+            'resources/js/Pages/**/*.jsx' => [$testPath, $browserDir],
+            'resources/js/Pages/**/*.svelte' => [$testPath, $browserDir],
+
+            // Shared layouts / components consumed by pages.
+            'resources/js/Layouts/**/*.vue' => [$browserDir],
+            'resources/js/Layouts/**/*.tsx' => [$browserDir],
+            'resources/js/Components/**/*.vue' => [$browserDir],
+            'resources/js/Components/**/*.tsx' => [$browserDir],
+
+            // SSR entry point.
+            'resources/js/ssr.js' => [$browserDir],
+            'resources/js/ssr.ts' => [$browserDir],
+            'resources/js/app.js' => [$browserDir],
+            'resources/js/app.ts' => [$browserDir],
+        ];
+    }
+}

src/Plugins/Tia/WatchDefaults/Laravel.php

@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+
+/**
+ * Watch patterns for Laravel projects.
+ *
+ * Laravel boots the entire application inside `setUp()` (before PHPUnit's
+ * `Prepared` event where TIA's coverage window opens). That means PHP files
+ * loaded during boot — config, routes, service providers, migrations — are
+ * invisible to the coverage driver. Watch patterns are the only way to
+ * track them.
+ *
+ * @internal
+ */
+final readonly class Laravel implements WatchDefault
+{
+    public function applicable(): bool
+    {
+        return class_exists(InstalledVersions::class)
+            && InstalledVersions::isInstalled('laravel/framework');
+    }
+
+    public function defaults(string $projectRoot, string $testPath): array
+    {
+        $featurePath = is_dir($projectRoot.DIRECTORY_SEPARATOR.$testPath.'/Feature')
+            ? $testPath.'/Feature'
+            : $testPath;
+
+        return [
+            // Config — loaded during app boot (setUp), invisible to coverage.
+            // Affects both Feature and Unit: Pest.php commonly binds fakes
+            // and seeds DB based on config values.
+            'config/*.php' => [$testPath],
+            'config/**/*.php' => [$testPath],
+
+            // Routes — loaded during boot. HTTP/Feature tests depend on them.
+            'routes/*.php' => [$featurePath],
+            'routes/**/*.php' => [$featurePath],
+
+            // Service providers / bootstrap — loaded during boot, affect
+            // bindings, middleware, event listeners, scheduled tasks.
+            'bootstrap/app.php' => [$testPath],
+            'bootstrap/providers.php' => [$testPath],
+
+            // Migrations — run via RefreshDatabase/FastRefreshDatabase in
+            // setUp. Schema changes can break any test that touches DB.
+            'database/migrations/**/*.php' => [$testPath],
+
+            // Seeders — often run globally via Pest.php beforeEach.
+            'database/seeders/**/*.php' => [$testPath],
+
+            // Factories — loaded lazily but still PHP that coverage may miss
+            // if the factory file was already autoloaded before Prepared.
+            'database/factories/**/*.php' => [$testPath],
+
+            // Blade templates — compiled to cache, source file not executed.
+            'resources/views/**/*.blade.php' => [$featurePath],
+
+            // Translations — JSON translations read via file_get_contents,
+            // PHP translations loaded via include (but during boot).
+            'lang/**/*.php' => [$featurePath],
+            'lang/**/*.json' => [$featurePath],
+            'resources/lang/**/*.php' => [$featurePath],
+            'resources/lang/**/*.json' => [$featurePath],
+
+            // Build tool config — affects compiled assets consumed by
+            // browser and Inertia tests.
+            'vite.config.js' => [$featurePath],
+            'vite.config.ts' => [$featurePath],
+            'webpack.mix.js' => [$featurePath],
+            'tailwind.config.js' => [$featurePath],
+            'tailwind.config.ts' => [$featurePath],
+            'postcss.config.js' => [$featurePath],
+        ];
+    }
+}

src/Plugins/Tia/WatchDefaults/Livewire.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+
+/**
+ * Watch patterns for projects using Livewire.
+ *
+ * Livewire components pair a PHP class with a Blade view. A view change can
+ * break rendering or assertions in feature / browser tests even though the
+ * PHP side is untouched.
+ *
+ * @internal
+ */
+final readonly class Livewire implements WatchDefault
+{
+    public function applicable(): bool
+    {
+        return class_exists(InstalledVersions::class)
+            && InstalledVersions::isInstalled('livewire/livewire');
+    }
+
+    public function defaults(string $projectRoot, string $testPath): array
+    {
+        return [
+            // Livewire views live alongside Blade views or in a dedicated dir.
+            'resources/views/livewire/**/*.blade.php' => [$testPath],
+            'resources/views/components/**/*.blade.php' => [$testPath],
+
+            // Livewire JS interop / Alpine plugins.
+            'resources/js/**/*.js' => [$testPath],
+            'resources/js/**/*.ts' => [$testPath],
+        ];
+    }
+}

src/Plugins/Tia/WatchDefaults/Php.php

@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+/**
+ * Baseline watch patterns for any PHP project.
+ *
+ * @internal
+ */
+final readonly class Php implements WatchDefault
+{
+    public function applicable(): bool
+    {
+        return true;
+    }
+
+    public function defaults(string $projectRoot, string $testPath): array
+    {
+        // NOTE: composer.json / composer.lock changes are caught by the
+        // fingerprint (which hashes composer.lock). PHP files are tracked by
+        // the coverage driver. Only non-PHP, non-fingerprinted files that
+        // can silently alter test behaviour belong here.
+
+        return [
+            // Environment files — can change DB drivers, feature flags,
+            // queue connections, etc. Not PHP, not fingerprinted.
+            '.env' => [$testPath],
+            '.env.testing' => [$testPath],
+
+            // Docker / CI — can affect integration test infrastructure.
+            'docker-compose.yml' => [$testPath],
+            'docker-compose.yaml' => [$testPath],
+
+            // PHPUnit / Pest config (XML) — phpunit.xml IS fingerprinted, but
+            // phpunit.xml.dist and other XML overrides are not individually
+            // tracked by the coverage driver.
+            'phpunit.xml.dist' => [$testPath],
+
+            // Test fixtures — JSON, CSV, XML, TXT data files consumed by
+            // assertions. A fixture change can flip a test result.
+            $testPath.'/Fixtures/**/*.json' => [$testPath],
+            $testPath.'/Fixtures/**/*.csv' => [$testPath],
+            $testPath.'/Fixtures/**/*.xml' => [$testPath],
+            $testPath.'/Fixtures/**/*.txt' => [$testPath],
+
+            // Pest snapshots — external edits to snapshot files invalidate
+            // snapshot assertions.
+            $testPath.'/.pest/snapshots/**/*.snap' => [$testPath],
+        ];
+    }
+}

src/Plugins/Tia/WatchDefaults/Symfony.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+use Composer\InstalledVersions;
+
+/**
+ * Watch patterns for Symfony projects.
+ *
+ * @internal
+ */
+final readonly class Symfony implements WatchDefault
+{
+    public function applicable(): bool
+    {
+        return class_exists(InstalledVersions::class)
+            && InstalledVersions::isInstalled('symfony/framework-bundle');
+    }
+
+    public function defaults(string $projectRoot, string $testPath): array
+    {
+        // Symfony boots the kernel in setUp() (before the coverage window).
+        // PHP config, routes, kernel, and migrations are loaded during boot
+        // and invisible to the coverage driver. Same reasoning as Laravel.
+
+        return [
+            // Config — YAML, XML, and PHP. All loaded during kernel boot.
+            'config/*.yaml' => [$testPath],
+            'config/*.yml' => [$testPath],
+            'config/*.php' => [$testPath],
+            'config/*.xml' => [$testPath],
+            'config/**/*.yaml' => [$testPath],
+            'config/**/*.yml' => [$testPath],
+            'config/**/*.php' => [$testPath],
+            'config/**/*.xml' => [$testPath],
+
+            // Routes — loaded during boot.
+            'config/routes/*.yaml' => [$testPath],
+            'config/routes/*.php' => [$testPath],
+            'config/routes/*.xml' => [$testPath],
+            'config/routes/**/*.yaml' => [$testPath],
+
+            // Kernel / bootstrap — loaded during boot.
+            'src/Kernel.php' => [$testPath],
+
+            // Migrations — run during setUp (before coverage window).
+            'migrations/**/*.php' => [$testPath],
+
+            // Twig templates — compiled, source not PHP-executed.
+            'templates/**/*.html.twig' => [$testPath],
+            'templates/**/*.twig' => [$testPath],
+
+            // Translations (YAML / XLF / XLIFF).
+            'translations/**/*.yaml' => [$testPath],
+            'translations/**/*.yml' => [$testPath],
+            'translations/**/*.xlf' => [$testPath],
+            'translations/**/*.xliff' => [$testPath],
+
+            // Doctrine XML/YAML mappings.
+            'config/doctrine/**/*.xml' => [$testPath],
+            'config/doctrine/**/*.yaml' => [$testPath],
+
+            // Webpack Encore / asset-mapper config + frontend sources.
+            'webpack.config.js' => [$testPath],
+            'importmap.php' => [$testPath],
+            'assets/**/*.js' => [$testPath],
+            'assets/**/*.ts' => [$testPath],
+            'assets/**/*.vue' => [$testPath],
+            'assets/**/*.css' => [$testPath],
+            'assets/**/*.scss' => [$testPath],
+        ];
+    }
+}

src/Plugins/Tia/WatchDefaults/WatchDefault.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia\WatchDefaults;
+
+/**
+ * A set of file-watch patterns that apply when a particular framework,
+ * library or project layout is detected.
+ *
+ * Each implementation probes for the presence of the tool it covers
+ * (`applicable`) and returns glob → test-directory mappings (`defaults`)
+ * that are merged into `WatchPatterns`.
+ *
+ * @internal
+ */
+interface WatchDefault
+{
+    /**
+     * Whether this default set applies to the current project.
+     */
+    public function applicable(): bool;
+
+    /**
+     * @return array<string, array<int, string>> glob → list of project-relative test dirs
+     */
+    public function defaults(string $projectRoot, string $testPath): array;
+}

src/Plugins/Tia/WatchPatterns.php

@@ -0,0 +1,188 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Plugins\Tia;
+
+use Pest\Plugins\Tia\WatchDefaults\WatchDefault;
+use Pest\TestSuite;
+
+/**
+ * Maps non-PHP file globs to the test directories they should invalidate.
+ *
+ * Coverage drivers only see `.php` files. Frontend assets, config files,
+ * Blade templates, routes and environment files are invisible to the graph.
+ * Watch patterns bridge the gap: when a changed file matches a glob, every
+ * test under the associated directory is marked as affected.
+ *
+ * Defaults are assembled dynamically from the `WatchDefaults/` registry —
+ * each implementation probes the current project and contributes patterns
+ * when applicable. Users extend via `pest()->tia()->watch(…)`.
+ *
+ * @internal
+ */
+final class WatchPatterns
+{
+    /**
+     * All known default providers, in evaluation order.
+     *
+     * @var array<int, class-string<WatchDefault>>
+     */
+    private const array DEFAULTS = [
+        WatchDefaults\Php::class,
+        WatchDefaults\Laravel::class,
+        WatchDefaults\Symfony::class,
+        WatchDefaults\Livewire::class,
+        WatchDefaults\Inertia::class,
+        WatchDefaults\Browser::class,
+    ];
+
+    /**
+     * @var array<string, array<int, string>> glob → list of project-relative test dirs
+     */
+    private array $patterns = [];
+
+    /**
+     * Probes every registered `WatchDefault` and merges the patterns of
+     * those that apply. Called once during Tia plugin boot, after BootFiles
+     * has loaded `tests/Pest.php` (so user-added `pest()->tia()->watch()`
+     * calls are already in `$this->patterns`).
+     */
+    public function useDefaults(string $projectRoot): void
+    {
+        $testPath = TestSuite::getInstance()->testPath;
+
+        foreach (self::DEFAULTS as $class) {
+            $default = new $class;
+
+            if (! $default->applicable()) {
+                continue;
+            }
+
+            foreach ($default->defaults($projectRoot, $testPath) as $glob => $dirs) {
+                $this->patterns[$glob] = array_values(array_unique(
+                    array_merge($this->patterns[$glob] ?? [], $dirs),
+                ));
+            }
+        }
+    }
+
+    /**
+     * Adds user-defined patterns. Merges with existing entries so a single
+     * glob can map to multiple directories.
+     *
+     * @param  array<string, string>  $patterns  glob → project-relative test dir
+     */
+    public function add(array $patterns): void
+    {
+        foreach ($patterns as $glob => $dir) {
+            $this->patterns[$glob] = array_values(array_unique(
+                array_merge($this->patterns[$glob] ?? [], [$dir]),
+            ));
+        }
+    }
+
+    /**
+     * Returns all test directories whose watch patterns match at least one of
+     * the given changed files.
+     *
+     * @param  string  $projectRoot  Absolute path.
+     * @param  array<int, string>  $changedFiles  Project-relative paths.
+     * @return array<int, string> Project-relative test directories.
+     */
+    public function matchedDirectories(string $projectRoot, array $changedFiles): array
+    {
+        if ($this->patterns === []) {
+            return [];
+        }
+
+        $matched = [];
+
+        foreach ($changedFiles as $file) {
+            foreach ($this->patterns as $glob => $dirs) {
+                if ($this->globMatches($glob, $file)) {
+                    foreach ($dirs as $dir) {
+                        $matched[$dir] = true;
+                    }
+                }
+            }
+        }
+
+        return array_keys($matched);
+    }
+
+    /**
+     * Given the affected directories, returns every test file in the graph
+     * that lives under one of those directories.
+     *
+     * @param  array<int, string>  $directories  Project-relative dirs.
+     * @param  array<int, string>  $allTestFiles  Project-relative test files from graph.
+     * @return array<int, string>
+     */
+    public function testsUnderDirectories(array $directories, array $allTestFiles): array
+    {
+        if ($directories === []) {
+            return [];
+        }
+
+        $affected = [];
+
+        foreach ($allTestFiles as $testFile) {
+            foreach ($directories as $dir) {
+                $prefix = rtrim($dir, '/').'/';
+
+                if (str_starts_with($testFile, $prefix)) {
+                    $affected[] = $testFile;
+
+                    break;
+                }
+            }
+        }
+
+        return $affected;
+    }
+
+    public function reset(): void
+    {
+        $this->patterns = [];
+    }
+
+    /**
+     * Matches a project-relative file against a glob pattern.
+     *
+     * Supports `*` (single segment), `**` (any depth) and `?`.
+     */
+    private function globMatches(string $pattern, string $file): bool
+    {
+        $pattern = str_replace('\\', '/', $pattern);
+        $file = str_replace('\\', '/', $file);
+
+        $regex = '';
+        $len = strlen($pattern);
+        $i = 0;
+
+        while ($i < $len) {
+            $c = $pattern[$i];
+
+            if ($c === '*' && isset($pattern[$i + 1]) && $pattern[$i + 1] === '*') {
+                $regex .= '.*';
+                $i += 2;
+
+                if (isset($pattern[$i]) && $pattern[$i] === '/') {
+                    $i++;
+                }
+            } elseif ($c === '*') {
+                $regex .= '[^/]*';
+                $i++;
+            } elseif ($c === '?') {
+                $regex .= '[^/]';
+                $i++;
+            } else {
+                $regex .= preg_quote($c, '#');
+                $i++;
+            }
+        }
+
+        return (bool) preg_match('#^'.$regex.'$#', $file);
+    }
+}

src/Subscribers/EnsureTiaAssertionsAreRecordedOnFinished.php

@@ -0,0 +1,34 @@
+<?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 class EnsureTiaAssertionsAreRecordedOnFinished implements FinishedSubscriber
+{
+    public function __construct(private readonly ResultCollector $collector) {}
+
+    public function notify(Finished $event): void
+    {
+        $test = $event->test();
+
+        if ($test instanceof TestMethod) {
+            $this->collector->recordAssertions(
+                $test->className().'::'.$test->methodName(),
+                $event->numberOfAssertionsPerformed(),
+            );
+        }
+    }
+}

src/Subscribers/EnsureTiaCoverageIsFlushed.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\Recorder;
+use PHPUnit\Event\Test\Finished;
+use PHPUnit\Event\Test\FinishedSubscriber;
+
+/**
+ * Stops PCOV collection after each test and merges the covered files into the
+ * TIA recorder's aggregate map. No-op unless the recorder is active.
+ *
+ * @internal
+ */
+final readonly class EnsureTiaCoverageIsFlushed implements FinishedSubscriber
+{
+    public function __construct(private Recorder $recorder) {}
+
+    public function notify(Finished $event): void
+    {
+        $this->recorder->endTest();
+    }
+}

src/Subscribers/EnsureTiaCoverageIsRecorded.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\Recorder;
+use PHPUnit\Event\Code\TestMethod;
+use PHPUnit\Event\Test\Prepared;
+use PHPUnit\Event\Test\PreparedSubscriber;
+
+/**
+ * Starts PCOV collection before each test. No-op unless the TIA recorder was
+ * activated by the `--tia` plugin.
+ *
+ * @internal
+ */
+final readonly class EnsureTiaCoverageIsRecorded implements PreparedSubscriber
+{
+    public function __construct(private Recorder $recorder) {}
+
+    public function notify(Prepared $event): void
+    {
+        if (! $this->recorder->isActive()) {
+            return;
+        }
+
+        $test = $event->test();
+
+        if (! $test instanceof TestMethod) {
+            return;
+        }
+
+        $this->recorder->beginTest($test->className(), $test->methodName(), $test->file());
+    }
+}

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 class EnsureTiaResultIsRecordedOnErrored implements ErroredSubscriber
+{
+    public function __construct(private readonly 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 class EnsureTiaResultIsRecordedOnFailed implements FailedSubscriber
+{
+    public function __construct(private readonly 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 class EnsureTiaResultIsRecordedOnIncomplete implements MarkedIncompleteSubscriber
+{
+    public function __construct(private readonly 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 class EnsureTiaResultIsRecordedOnPassed implements PassedSubscriber
+{
+    public function __construct(private readonly 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 class EnsureTiaResultIsRecordedOnRisky implements ConsideredRiskySubscriber
+{
+    public function __construct(private readonly 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 class EnsureTiaResultIsRecordedOnSkipped implements SkippedSubscriber
+{
+    public function __construct(private readonly ResultCollector $collector) {}
+
+    public function notify(Skipped $event): void
+    {
+        $this->collector->testSkipped($event->message());
+    }
+}

src/Subscribers/EnsureTiaResultsAreCollected.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Pest\Subscribers;
+
+use Pest\Plugins\Tia\ResultCollector;
+use PHPUnit\Event\Code\TestMethod;
+use PHPUnit\Event\Test\Prepared;
+use PHPUnit\Event\Test\PreparedSubscriber;
+
+/**
+ * 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 PreparedSubscriber
+{
+    public function __construct(private readonly ResultCollector $collector) {}
+
+    public function notify(Prepared $event): void
+    {
+        $test = $event->test();
+
+        if ($test instanceof TestMethod) {
+            $this->collector->testPrepared($test->className().'::'.$test->methodName());
+        }
+    }
+}

tests/Arch.php

@@ -7,6 +7,9 @@ arch()->preset()->php()->ignoring([
     'debug_backtrace',
     'var_export',
     'xdebug_info',
+    'xdebug_start_code_coverage',
+    'xdebug_stop_code_coverage',
+    'xdebug_get_code_coverage',
 ]);
 
 arch()->preset()->strict()->ignoring([