diff --git a/.github/.release-please-config.json b/.github/.release-please-config.json
index 740af07..77d8757 100644
--- a/.github/.release-please-config.json
+++ b/.github/.release-please-config.json
@@ -112,6 +112,12 @@
             "component": "bridge-rector",
             "include-component-in-tag": true,
             "changelog-path": "CHANGELOG.md"
+        },
+        "bridge/revolt": {
+            "package-name": "testo/bridge-revolt",
+            "component": "bridge-revolt",
+            "include-component-in-tag": true,
+            "changelog-path": "CHANGELOG.md"
         }
     },
     "bump-patch-for-minor-pre-major": true,
diff --git a/.github/workflows/split-publish.yml b/.github/workflows/split-publish.yml
index 914d4fc..49dc9ea 100644
--- a/.github/workflows/split-publish.yml
+++ b/.github/workflows/split-publish.yml
@@ -22,6 +22,7 @@ on:  # yamllint disable-line rule:truthy
       - 'bridge-infection-[0-9]*'
       - 'bridge-mockery-[0-9]*'
       - 'bridge-rector-[0-9]*'
+      - 'bridge-revolt-[0-9]*'
       - 'bridge-symfony-console-[0-9]*'
       - 'codecov-[0-9]*'
       - 'convention-[0-9]*'
diff --git a/bridge/mockery/src/Internal/MockeryInterceptor.php b/bridge/mockery/src/Internal/MockeryInterceptor.php
index ff2a0d0..18ca1af 100644
--- a/bridge/mockery/src/Internal/MockeryInterceptor.php
+++ b/bridge/mockery/src/Internal/MockeryInterceptor.php
@@ -8,6 +8,7 @@
 use Testo\Assert\Internal\StaticState;
 use Testo\Assert\State\Expectation\ExpectationFailed;
 use Testo\Assert\State\Expectation\ExpectationFulfilled;
+use Testo\Bridge\Mockery\MockeryConcurrencyException;
 use Testo\Core\Context\TestInfo;
 use Testo\Core\Context\TestResult;
 use Testo\Core\Value\Status;
@@ -22,6 +23,14 @@
  *
  * Runs innermost so the teardown fires as close as possible to the test function.
  *
+ * Mockery's mock container is process-global static state, so — unlike Testo's own fiber-local guards —
+ * it cannot be isolated per fiber. This guard therefore serializes: it runs the test directly (no fiber
+ * trampoline, so it cooperates with a real event loop) and, if another Mockery test is already in flight,
+ * refuses to start with a {@see MockeryConcurrencyException}. That only happens under interleaving
+ * ({@see \Testo\Fiber\Schedule::RoundRobin}/`Random`, {@see \Testo\Bridge\Revolt\Strategy::PerCase}),
+ * where siblings would clobber each other's mocks. One-at-a-time execution — `Solo`/`PerTest` or no
+ * fibers — is fully supported, including across a real event-loop suspension.
+ *
  * @internal
  * @psalm-internal Testo\Bridge\Mockery
  */
@@ -29,15 +38,26 @@
     order: InterceptorOptions::ORDER_CLOSE_TO_TEST,
     testType: TestType::Test,
 )]
-final readonly class MockeryInterceptor implements TestRunInterceptor
+final class MockeryInterceptor implements TestRunInterceptor
 {
+    /**
+     * Whether a Mockery-guarded test is currently running. The container is process-global, so a second
+     * test starting while this is set means two tests are interleaving over the same container.
+     */
+    private static bool $running = false;
+
     #[\Override]
     public function runTest(TestInfo $info, callable $next): TestResult
     {
+        self::$running and throw new MockeryConcurrencyException();
+        self::$running = true;
+
         $result = null;
         try {
-            $result = $this->run($info, $next);
+            $result = $next($info);
         } finally {
+            self::$running = false;
+
             # close() clears the container, so read the count first.
             $verified = \Mockery::getContainer()->mockery_getExpectationCount();
             try {
@@ -100,42 +120,4 @@ private static function reportFailedExpectation(\Throwable $e): ?ExpectationFail
 
         return $failure;
     }
-
-    /**
-     * Run the test, keeping the global Mockery container bound to it across fiber suspensions.
-     *
-     * The container is process-global static state, so under concurrent (fiber-based) execution
-     * sibling tests would clobber each other's mocks. On every suspension we save this test's
-     * container and reset the global one; on resumption we restore it — the same scope-guarding
-     * dance as {@see \Testo\Application\Internal\MessengerHub::scope()}.
-     *
-     * @param callable(TestInfo): TestResult $next
-     */
-    private function run(TestInfo $info, callable $next): TestResult
-    {
-        if (\Fiber::getCurrent() === null) {
-            return $next($info);
-        }
-
-        $fiber = new \Fiber(static fn(): TestResult => $next($info));
-        $value = $fiber->start();
-        while (!$fiber->isTerminated()) {
-            $container = \Mockery::getContainer();
-            \Mockery::resetContainer();
-            try {
-                $resume = \Fiber::suspend($value);
-            } catch (\Throwable $e) {
-                \Mockery::setContainer($container);
-                $value = $fiber->throw($e);
-                continue;
-            }
-
-            \Mockery::setContainer($container);
-            $value = $fiber->resume($resume);
-        }
-
-        /** @var TestResult $result */
-        $result = $fiber->getReturn();
-        return $result;
-    }
 }
diff --git a/bridge/mockery/src/MockeryConcurrencyException.php b/bridge/mockery/src/MockeryConcurrencyException.php
new file mode 100644
index 0000000..299d526
--- /dev/null
+++ b/bridge/mockery/src/MockeryConcurrencyException.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Bridge\Mockery;
+
+/**
+ * Thrown when a Mockery-guarded test starts while another one is still in flight — i.e. under
+ * interleaving execution, where sibling tests would clobber each other's mocks.
+ *
+ * Mockery's mock container is process-global static state and cannot be isolated per fiber, so the
+ * bridge serializes Mockery tests. Run them one at a time — {@see \Testo\Fiber\Schedule::Solo} /
+ * {@see \Testo\Bridge\Revolt\Strategy::PerTest} (or without fibers at all) — rather than interleaved
+ * ({@see \Testo\Fiber\Schedule::RoundRobin}/`Random`, {@see \Testo\Bridge\Revolt\Strategy::PerCase}).
+ *
+ * @api
+ */
+final class MockeryConcurrencyException extends \RuntimeException
+{
+    public function __construct()
+    {
+        parent::__construct(
+            'Mockery cannot run under interleaving test execution: its mock container is process-global '
+            . 'and cannot be isolated per fiber, so concurrently running tests would clobber each other\'s '
+            . 'mocks. Run Mockery tests one at a time (Schedule::Solo / Strategy::PerTest, or no fibers), '
+            . 'not interleaved (Schedule::RoundRobin/Random, Strategy::PerCase).',
+        );
+    }
+}
diff --git a/bridge/mockery/tests/Feature/MockeryStatusTest.php b/bridge/mockery/tests/Feature/MockeryStatusTest.php
index 8bb3f5d..5106c92 100644
--- a/bridge/mockery/tests/Feature/MockeryStatusTest.php
+++ b/bridge/mockery/tests/Feature/MockeryStatusTest.php
@@ -14,6 +14,7 @@
 use Testo\Test;
 use Testo\Testing\Attribute\TestingSuite;
 use Testo\Testing\Helper\TestRunner;
+use Tests\Bridge\Mockery\Stub\MockeryConcurrencyScenarios;
 use Tests\Bridge\Mockery\Stub\MockeryResetScenarios;
 use Tests\Bridge\Mockery\Stub\MockeryScenarios;
 
@@ -71,6 +72,19 @@ public function stateIsResetAfterAFailingTest(): void
         Assert::same($next->status, Status::Passed);
     }
 
+    public function interleavedMockeryTestsAreRejected(): void
+    {
+        // Under Schedule::RoundRobin the two scenario tests interleave: the first parks mid-mock, so the
+        // second starts while the global container is still the first's. That second test must abort with
+        // a MockeryConcurrencyException rather than silently clobbering the first's mocks; the first,
+        // running one at a time from its own point of view, still passes.
+        $second = TestRunner::runTest([MockeryConcurrencyScenarios::class, 'secondMockAcrossSuspend']);
+        Assert::same($second->status, Status::Aborted);
+
+        $first = TestRunner::runTest([MockeryConcurrencyScenarios::class, 'firstMockAcrossSuspend']);
+        Assert::same($first->status, Status::Passed);
+    }
+
     /**
      * Whether the test's assertion history holds a record with the given success flag — i.e. the
      * bridge reported the mock verification (fulfilled or failed) to the Assert plugin.
diff --git a/bridge/mockery/tests/Self/MockeryUnderFibersTest.php b/bridge/mockery/tests/Self/MockeryUnderFibersTest.php
new file mode 100644
index 0000000..b62f8b8
--- /dev/null
+++ b/bridge/mockery/tests/Self/MockeryUnderFibersTest.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Bridge\Mockery\Self;
+
+use Revolt\EventLoop;
+use Testo\Assert;
+use Testo\Bridge\Mockery\Internal\MockeryInterceptor;
+use Testo\Bridge\Mockery\MockeryPlugin;
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Codecov\Covers;
+use Testo\Fiber\RunInFiber;
+use Testo\Test;
+
+/**
+ * Mockery under one-at-a-time fiber execution — the supported case after the trampoline was dropped.
+ * A mock set up inside a scheduler fiber (Solo) and one carried across a real Revolt await both verify
+ * normally: with no sibling test running, the process-global container stays this test's throughout.
+ */
+#[Test]
+#[Covers(MockeryPlugin::class, MockeryInterceptor::class)]
+final class MockeryUnderFibersTest
+{
+    #[RunInFiber]
+    public function mockVerifiesInsideASoloFiber(): void
+    {
+        /** @var \Mockery\MockInterface&\Countable $mock */
+        $mock = \Mockery::mock(\Countable::class);
+        $mock->expects('count')->once()->andReturn(4);
+
+        Assert::same($mock->count(), 4);
+    }
+
+    #[RunInRevolt]
+    public function mockVerifiesAcrossARevoltAwait(): void
+    {
+        /** @var \Mockery\MockInterface&\Countable $mock */
+        $mock = \Mockery::mock(\Countable::class);
+        $mock->expects('count')->once()->andReturn(7);
+
+        $suspension = EventLoop::getSuspension();
+        EventLoop::delay(0.001, static fn() => $suspension->resume());
+        $suspension->suspend();
+
+        Assert::same($mock->count(), 7);
+    }
+}
diff --git a/bridge/mockery/tests/Stub/MockeryConcurrencyScenarios.php b/bridge/mockery/tests/Stub/MockeryConcurrencyScenarios.php
new file mode 100644
index 0000000..273b1f4
--- /dev/null
+++ b/bridge/mockery/tests/Stub/MockeryConcurrencyScenarios.php
@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Bridge\Mockery\Stub;
+
+use Mockery\MockInterface;
+use Testo\Fiber\RunInFiber;
+use Testo\Fiber\Schedule;
+use Testo\Test;
+
+/**
+ * Two Mockery tests forced to **interleave** on Testo's fiber scheduler ({@see Schedule::RoundRobin}):
+ * each sets up a mock, yields at `\Fiber::suspend()`, then uses it. Because Mockery's container is
+ * process-global, the second test to start (while the first is parked mid-mock) must be rejected with a
+ * {@see \Testo\Bridge\Mockery\MockeryConcurrencyException}. Driven through {@see
+ * \Testo\Testing\Helper\TestRunner} by the Feature suite.
+ */
+#[Test]
+#[RunInFiber(Schedule::RoundRobin)]
+final class MockeryConcurrencyScenarios
+{
+    public function firstMockAcrossSuspend(): void
+    {
+        /** @var MockInterface&\Countable $mock */
+        $mock = \Mockery::mock(\Countable::class);
+        $mock->expects('count')->once()->andReturn(1);
+
+        \Fiber::suspend();
+
+        $mock->count();
+    }
+
+    public function secondMockAcrossSuspend(): void
+    {
+        /** @var MockInterface&\Countable $mock */
+        $mock = \Mockery::mock(\Countable::class);
+        $mock->expects('count')->once()->andReturn(2);
+
+        \Fiber::suspend();
+
+        $mock->count();
+    }
+}
diff --git a/bridge/revolt/README.md b/bridge/revolt/README.md
new file mode 100644
index 0000000..f133d9b
--- /dev/null
+++ b/bridge/revolt/README.md
@@ -0,0 +1,60 @@
+<p align="center">
+    <a href="https://github.com/php-testo/testo"><img alt="TESTO"
+         src="https://github.com/php-testo/.github/blob/1.x/resources/logo-full.svg?raw=true"
+         style="width: 2in; display: block"
+    /></a>
+</p>
+
+<p align="center">Revolt event-loop bridge</p>
+
+<div align="center">
+
+[![Documentation](https://img.shields.io/badge/Documentation-blue?style=for-the-badge&logo=gitbook&logoColor=white)](https://php-testo.github.io)
+[![Support on Boosty](https://img.shields.io/static/v1?style=for-the-badge&label=&message=Sponsorship&logo=Boosty&logoColor=white&color=%23F15F2C)](https://boosty.to/roxblnfk)
+
+</div>
+
+<br />
+
+> [!IMPORTANT]
+> ## 🪞 This is a read-only mirror.
+>
+> Active development of the Testo project lives in [**php-testo/testo**](https://github.com/php-testo/testo) under `bridge/revolt/`. This repository is **automatically synchronized** from there on every release.
+>
+> File issues and pull requests in the [main monorepo](https://github.com/php-testo/testo/issues), not here.
+
+## About
+
+Runs a test on the process-global [Revolt](https://revolt.run) event loop, so the test body may `await` real async work (timers, streams, `Future::await()`, amphp libraries) and resume without blocking the process.
+
+- `#[RunInRevolt]` — run a test on the Revolt event loop for real async I/O. Applied to a class, it drives every test in the case.
+
+Suspension must go through a Revolt `Suspension` bound to a watcher (I/O, timer) — a bare `\Fiber::suspend()` has no resumer on the loop (that is the plain-fiber `#[RunInFiber]` from `testo/fiber`, a different concern).
+
+### Strategy
+
+`#[RunInRevolt]` takes a `Strategy` that chooses when the loop is entered:
+
+- `Strategy::PerTest` (default) — each test's whole pipeline is placed on the loop individually, one test at a time, each run to completion before the next. No interleaving.
+- `Strategy::PerCase` — launches the whole case's tests **concurrently** on one loop run via `CaseInfo`'s batch runner, interleaving at their await points.
+
+Either way the whole per-test pipeline runs inside the loop fiber. Testo's scoped-state guards (assertion collector, messenger) hold their state per fiber, so concurrent tests stay isolated — each reads its own assertion/messenger state across every switch.
+
+```php
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Bridge\Revolt\Strategy;
+
+#[RunInRevolt(Strategy::PerTest)]
+final class TimersTest { /* ... */ }
+```
+
+## Install
+
+```bash
+composer require --dev testo/bridge-revolt
+```
+
+[![PHP](https://img.shields.io/packagist/php-v/testo/bridge-revolt.svg?style=flat-square&logo=php)](https://packagist.org/packages/testo/bridge-revolt)
+[![Latest Version on Packagist](https://img.shields.io/packagist/v/testo/bridge-revolt.svg?style=flat-square&logo=packagist)](https://packagist.org/packages/testo/bridge-revolt)
+[![License](https://img.shields.io/packagist/l/testo/bridge-revolt.svg?style=flat-square)](https://github.com/php-testo/testo/blob/1.x/LICENSE.md)
+[![Total Downloads](https://img.shields.io/packagist/dt/testo/bridge-revolt.svg?style=flat-square)](https://packagist.org/packages/testo/bridge-revolt/stats)
diff --git a/bridge/revolt/composer.json b/bridge/revolt/composer.json
new file mode 100644
index 0000000..eee6657
--- /dev/null
+++ b/bridge/revolt/composer.json
@@ -0,0 +1,36 @@
+{
+    "name": "testo/bridge-revolt",
+    "description": "Revolt event-loop bridge for the Testo testing framework: run tests on the real event loop for async I/O.",
+    "license": "BSD-3-Clause",
+    "type": "library",
+    "keywords": [
+        "testo",
+        "revolt",
+        "event-loop",
+        "async",
+        "amphp"
+    ],
+    "authors": [
+        {
+            "name": "Aleksei Gagarin (roxblnfk)",
+            "homepage": "https://github.com/roxblnfk"
+        }
+    ],
+    "require": {
+        "php": ">=8.2",
+        "revolt/event-loop": "^1.0",
+        "testo/testo": "0.10.20 - 1"
+    },
+    "autoload": {
+        "psr-4": {
+            "Testo\\Bridge\\Revolt\\": "src/"
+        }
+    },
+    "minimum-stability": "dev",
+    "prefer-stable": true,
+    "extra": {
+        "branch-alias": {
+            "dev-1.x": "1.x-dev"
+        }
+    }
+}
diff --git a/bridge/revolt/src/Internal/RevoltTestBatchRunner.php b/bridge/revolt/src/Internal/RevoltTestBatchRunner.php
new file mode 100644
index 0000000..8f44770
--- /dev/null
+++ b/bridge/revolt/src/Internal/RevoltTestBatchRunner.php
@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Bridge\Revolt\Internal;
+
+use Revolt\EventLoop;
+use Testo\Bridge\Revolt\Strategy;
+use Testo\Core\Context\TestResult;
+
+/**
+ * Drives a case's test handlers **concurrently** on the process-global **Revolt** event loop.
+ *
+ * An invokable runner — set on {@see \Testo\Core\Context\CaseInfo::$batchRunner} by
+ * {@see RunInRevoltInterceptor::runTestCase()} under {@see Strategy::PerCase}. Every handler is launched
+ * as its own microtask (loop fiber) **at once**; they interleave at their await points and the calling
+ * fiber blocks on a {@see \Revolt\EventLoop\Suspension} until all of them finish.
+ *
+ * This runs the whole per-test pipeline — including Testo's scoped-state guards — inside a loop fiber.
+ * The guards hold their state per fiber (see {@see \Internal\Fiber\FiberLocal}), so concurrent tests keep
+ * separate assertion/messenger state across the interleave. See {@see Strategy::PerCase}.
+ *
+ * @internal
+ * @psalm-internal Testo\Bridge\Revolt
+ */
+final class RevoltTestBatchRunner
+{
+    /**
+     * Depth of loop-driven tests currently in flight. Lets {@see RunInRevoltInterceptor::runTest()}
+     * skip its own loop dispatch when a case-level runner already put the test on the loop.
+     */
+    private static int $depth = 0;
+
+    /**
+     * Whether a test is currently being driven on the loop by a runner.
+     */
+    public static function active(): bool
+    {
+        return self::$depth > 0;
+    }
+
+    /**
+     * Runs a single handler as a coroutine on the loop and blocks the current fiber until it returns.
+     *
+     * @param callable(): TestResult $handler
+     */
+    public static function runOnLoop(callable $handler): TestResult
+    {
+        $suspension = EventLoop::getSuspension();
+
+        EventLoop::queue(static function () use ($suspension, $handler): void {
+            ++self::$depth;
+            try {
+                $suspension->resume($handler());
+            } catch (\Throwable $e) {
+                $suspension->throw($e);
+            } finally {
+                --self::$depth;
+            }
+        });
+
+        /** @var TestResult */
+        return $suspension->suspend();
+    }
+
+    /**
+     * Launches every handler as its own coroutine on the loop at once and blocks the current fiber
+     * until all of them finish, preserving input order in the result.
+     *
+     * @param list<callable(): TestResult> $handlers
+     * @return list<TestResult>
+     */
+    public function __invoke(array $handlers): array
+    {
+        if ($handlers === []) {
+            return [];
+        }
+
+        $suspension = EventLoop::getSuspension();
+        $results = [];
+        $errors = [];
+        $pending = \count($handlers);
+
+        foreach ($handlers as $i => $handler) {
+            EventLoop::queue(static function () use ($i, $handler, $suspension, &$results, &$errors, &$pending): void {
+                ++self::$depth;
+                try {
+                    $results[$i] = $handler();
+                } catch (\Throwable $e) {
+                    $errors[$i] = $e;
+                } finally {
+                    --self::$depth;
+                    --$pending === 0 and $suspension->resume();
+                }
+            });
+        }
+
+        $suspension->suspend();
+
+        // Safety net: the loop must not unwind before every test finished. If a handler ever strands its
+        // loop fiber (a bare suspend with no resumer), this suspension would return with tests missing —
+        // fail loudly rather than silently dropping tests (a green run that ran nothing is the worst
+        // outcome). With the fiber-local guards in place this never fires in practice.
+        $done = \count($results) + \count($errors);
+        $done === \count($handlers) or throw new \RuntimeException(\sprintf(
+            'Revolt PerCase lost %d of %d test(s): the event loop unwound before they finished.',
+            \count($handlers) - $done,
+            \count($handlers),
+        ));
+
+        $errors === [] or throw \reset($errors);
+
+        \ksort($results);
+
+        return \array_values($results);
+    }
+}
diff --git a/bridge/revolt/src/Internal/RunInRevoltInterceptor.php b/bridge/revolt/src/Internal/RunInRevoltInterceptor.php
new file mode 100644
index 0000000..9f45515
--- /dev/null
+++ b/bridge/revolt/src/Internal/RunInRevoltInterceptor.php
@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Bridge\Revolt\Internal;
+
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Bridge\Revolt\Strategy;
+use Testo\Core\Context\CaseInfo;
+use Testo\Core\Context\CaseResult;
+use Testo\Core\Context\TestInfo;
+use Testo\Core\Context\TestResult;
+use Testo\Pipeline\Attribute\InterceptorOptions;
+use Testo\Pipeline\Middleware\TestCaseRunInterceptor;
+use Testo\Pipeline\Middleware\TestRunInterceptor;
+use Testo\Pipeline\Policy\ConflictPolicy;
+
+/**
+ * Drives {@see RunInRevolt} tests as coroutines on the Revolt event loop, per the chosen
+ * {@see Strategy}.
+ *
+ * - {@see Strategy::PerTest} (default): each test's whole pipeline is put on the loop by {@see runTest()},
+ *   one test at a time, each to completion.
+ * - {@see Strategy::PerCase}: the whole case is handed a {@see RevoltTestBatchRunner} (via
+ *   {@see CaseInfo::withBatchRunner()}) that launches every test at once, so they run concurrently and
+ *   interleave at their await points.
+ *
+ * Each test's pipeline is launched as a microtask and the current fiber blocks on a
+ * {@see \Revolt\EventLoop\Suspension} until it completes, so the test may await real async work while
+ * staying, from the outside, an ordinary blocking call.
+ *
+ * Sits **outer** to the fiber-aware scoped-state guards (order just outside {@see
+ * InterceptorOptions::ORDER_DATA_PROVIDER}): the loop dispatch wraps the guards, so the whole per-test
+ * pipeline — assertion collector, messenger scope, the test body — runs *inside* the loop fiber. The
+ * guards hold their state per fiber (see {@see \Internal\Fiber\FiberLocal}), so each test reads its own
+ * scoped state even while several tests interleave on one loop; a data-driven/retried test runs all its
+ * datasets/attempts inside its single fiber (data provider stays inner to the dispatch).
+ *
+ * @internal
+ * @psalm-internal Testo\Bridge\Revolt
+ */
+#[InterceptorOptions(order: InterceptorOptions::ORDER_DATA_PROVIDER - 1, onConflict: ConflictPolicy::Last)]
+final readonly class RunInRevoltInterceptor implements TestCaseRunInterceptor, TestRunInterceptor
+{
+    public function __construct(
+        private RunInRevolt $options,
+    ) {}
+
+    #[\Override]
+    public function runTestCase(CaseInfo $info, callable $next): CaseResult
+    {
+        // Per-case: hand the case a runner that launches every test on the loop at once (concurrent).
+        // Per-test leaves the case untouched and dispatches each test onto the loop individually, one at a
+        // time, in runTest().
+        return $this->options->strategy === Strategy::PerCase
+            ? $next($info->withBatchRunner(new RevoltTestBatchRunner()))
+            : $next($info);
+    }
+
+    #[\Override]
+    public function runTest(TestInfo $info, callable $next): TestResult
+    {
+        // A case-level runner already drove us onto the loop (Strategy::PerCase) — just run the pipeline.
+        if (RevoltTestBatchRunner::active()) {
+            return $next($info);
+        }
+
+        // Strategy::PerTest (or a method-level attribute): put this test's whole pipeline on the loop, so
+        // the fiber-local guards inner to us run in the same fiber as the test body.
+        return RevoltTestBatchRunner::runOnLoop(static fn(): TestResult => $next($info));
+    }
+}
diff --git a/bridge/revolt/src/RunInRevolt.php b/bridge/revolt/src/RunInRevolt.php
new file mode 100644
index 0000000..c17ef64
--- /dev/null
+++ b/bridge/revolt/src/RunInRevolt.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Bridge\Revolt;
+
+use Testo\Bridge\Revolt\Internal\RunInRevoltInterceptor;
+use Testo\Pipeline\Attribute\FallbackInterceptor;
+use Testo\Pipeline\Attribute\Interceptable;
+
+/**
+ * Runs a single test on the process-global **Revolt** event loop, so the test body may `await`
+ * real async work (timers, streams, `Future::await()`, amphp libraries) and resume without
+ * blocking the process.
+ *
+ * ```php
+ *  use Testo\Bridge\Revolt\RunInRevolt;
+ *  use Revolt\EventLoop;
+ *
+ *  #[RunInRevolt]
+ *  public function fetchesConcurrently(): void
+ *  {
+ *      $suspension = EventLoop::getSuspension();
+ *      EventLoop::delay(0.1, static fn() => $suspension->resume('ready'));
+ *      Assert::same($suspension->suspend(), 'ready'); // the loop runs while we wait
+ *  }
+ * ```
+ *
+ * Unlike the plain-fiber `#[RunInFiber]` (the `testo/fiber` plugin, where Testo's own scheduler drives
+ * the fiber), here the **Revolt loop** owns the fiber, so suspension must go through a Revolt
+ * `Suspension` bound to a watcher (I/O, timer) — a bare `\Fiber::suspend()` has no resumer on the loop.
+ *
+ * The {@see Strategy} chooses when the loop is entered — {@see Strategy::PerTest} (default, one test on
+ * the loop at a time, each run to completion) or {@see Strategy::PerCase} (launches the whole case's tests
+ * concurrently on one loop run, interleaving at their await points). Either way the whole per-test
+ * pipeline runs inside the loop fiber; Testo's scoped-state guards hold their state per fiber (see
+ * {@see \Internal\Fiber\FiberLocal}), so concurrent tests stay isolated.
+ *
+ * @api
+ */
+#[\Attribute(\Attribute::TARGET_CLASS | \Attribute::TARGET_METHOD)]
+#[FallbackInterceptor(RunInRevoltInterceptor::class)]
+final readonly class RunInRevolt implements Interceptable
+{
+    public function __construct(
+        public Strategy $strategy = Strategy::PerTest,
+    ) {}
+}
diff --git a/bridge/revolt/src/Strategy.php b/bridge/revolt/src/Strategy.php
new file mode 100644
index 0000000..4af5e60
--- /dev/null
+++ b/bridge/revolt/src/Strategy.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Bridge\Revolt;
+
+/**
+ * When {@see RunInRevolt} enters the Revolt event loop for a case's tests.
+ *
+ * @api
+ */
+enum Strategy
+{
+    /**
+     * Enter the loop **per test**: each test's whole pipeline is placed on the loop individually, one test
+     * at a time, each run to completion before the next. The safe default — no interleaving, so tests
+     * never observe each other's scoped state.
+     */
+    case PerTest;
+
+    /**
+     * Enter the loop **per case**: the whole case is driven on the loop through
+     * {@see \Testo\Core\Context\CaseInfo::$batchRunner}, which launches every test as its own coroutine
+     * **at once** so they run concurrently, interleaving at their await points.
+     *
+     * The per-test pipeline — including Testo's fiber-aware scoped-state guards — runs inside a loop fiber.
+     * The guards hold their state per fiber (see {@see \Internal\Fiber\FiberLocal}), so each test reads its
+     * own assertion/messenger state even while several tests interleave on one loop.
+     */
+    case PerCase;
+}
diff --git a/bridge/revolt/tests/Self/PerCaseParallelTest.php b/bridge/revolt/tests/Self/PerCaseParallelTest.php
new file mode 100644
index 0000000..7d2c00a
--- /dev/null
+++ b/bridge/revolt/tests/Self/PerCaseParallelTest.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Bridge\Revolt\Self;
+
+use Revolt\EventLoop;
+use Testo\Assert;
+use Testo\Bridge\Revolt\Internal\RevoltTestBatchRunner;
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Bridge\Revolt\Strategy;
+use Testo\Codecov\Covers;
+use Testo\Test;
+
+/**
+ * A class-level `#[RunInRevolt(Strategy::PerCase)]` launches the case's tests concurrently on the Revolt
+ * loop: both start, both park on their own timer, and both resume once the loop drives the timers. The
+ * per-test pipeline runs inside a loop fiber, and the fiber-local scoped-state guards keep each test's
+ * assertion state isolated across the interleave — so both tests pass without clashing.
+ */
+#[Test]
+#[RunInRevolt(Strategy::PerCase)]
+#[Covers(RevoltTestBatchRunner::class)]
+final class PerCaseParallelTest
+{
+    public function firstAwaitsATimer(): void
+    {
+        $suspension = EventLoop::getSuspension();
+        EventLoop::delay(0.001, static fn() => $suspension->resume());
+        $suspension->suspend();
+
+        Assert::same(1, 1);
+    }
+
+    public function secondAwaitsATimer(): void
+    {
+        $suspension = EventLoop::getSuspension();
+        EventLoop::delay(0.001, static fn() => $suspension->resume());
+        $suspension->suspend();
+
+        Assert::same(2, 2);
+    }
+}
diff --git a/bridge/revolt/tests/Self/RunInRevoltTest.php b/bridge/revolt/tests/Self/RunInRevoltTest.php
new file mode 100644
index 0000000..a6c3aec
--- /dev/null
+++ b/bridge/revolt/tests/Self/RunInRevoltTest.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Bridge\Revolt\Self;
+
+use Revolt\EventLoop;
+use Testo\Assert;
+use Testo\Bridge\Revolt\Internal\RunInRevoltInterceptor;
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Codecov\Covers;
+use Testo\Test;
+
+/**
+ * Self-test: a `#[RunInRevolt]` test runs as a coroutine on the Revolt event loop — it executes inside
+ * a fiber and can await real async work (a timer) and resume without blocking the process.
+ */
+#[Test]
+#[RunInRevolt]
+#[Covers(RunInRevolt::class)]
+#[Covers(RunInRevoltInterceptor::class)]
+final class RunInRevoltTest
+{
+    public function runsInsideAFiber(): void
+    {
+        Assert::notNull(\Fiber::getCurrent());
+    }
+
+    public function awaitsATimerAndResumes(): void
+    {
+        $suspension = EventLoop::getSuspension();
+        EventLoop::delay(0.001, static fn() => $suspension->resume('resumed'));
+
+        Assert::same($suspension->suspend(), 'resumed');
+    }
+}
diff --git a/bridge/revolt/tests/Unit/RunInRevoltInterceptorTest.php b/bridge/revolt/tests/Unit/RunInRevoltInterceptorTest.php
new file mode 100644
index 0000000..33ebb69
--- /dev/null
+++ b/bridge/revolt/tests/Unit/RunInRevoltInterceptorTest.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Bridge\Revolt\Unit;
+
+use Testo\Assert;
+use Testo\Bridge\Revolt\Internal\RevoltTestBatchRunner;
+use Testo\Bridge\Revolt\Internal\RunInRevoltInterceptor;
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Bridge\Revolt\Strategy;
+use Testo\Codecov\Covers;
+use Testo\Core\Context\CaseInfo;
+use Testo\Core\Context\CaseResult;
+use Testo\Core\Definition\CaseDefinition;
+use Testo\Core\Value\Status;
+use Testo\Test;
+
+/**
+ * Unit: {@see RunInRevoltInterceptor::runTestCase()} wires the case for the chosen {@see Strategy}
+ * without touching the event loop — {@see Strategy::PerCase} hands the case a batch runner,
+ * {@see Strategy::PerTest} leaves it alone (the loop is entered per test in `runTest()` instead).
+ */
+#[Test]
+#[Covers(RunInRevoltInterceptor::class)]
+#[Covers(Strategy::class)]
+#[Covers(RevoltTestBatchRunner::class)]
+final class RunInRevoltInterceptorTest
+{
+    public function perCaseStrategySetsBatchRunnerOnTheCase(): void
+    {
+        $captured = null;
+        $next = static function (CaseInfo $info) use (&$captured): CaseResult {
+            $captured = $info;
+            return new CaseResult(results: [], status: Status::Passed);
+        };
+
+        (new RunInRevoltInterceptor(new RunInRevolt(Strategy::PerCase)))
+            ->runTestCase($this->caseInfo(), $next);
+
+        Assert::notNull($captured?->batchRunner);
+    }
+
+    public function perTestStrategyLeavesTheCaseRunnerUnset(): void
+    {
+        $captured = null;
+        $next = static function (CaseInfo $info) use (&$captured): CaseResult {
+            $captured = $info;
+            return new CaseResult(results: [], status: Status::Passed);
+        };
+
+        (new RunInRevoltInterceptor(new RunInRevolt(Strategy::PerTest)))
+            ->runTestCase($this->caseInfo(), $next);
+
+        Assert::same(null, $captured?->batchRunner);
+    }
+
+    public function defaultStrategyIsPerTest(): void
+    {
+        Assert::same(Strategy::PerTest, (new RunInRevolt())->strategy);
+    }
+
+    private function caseInfo(): CaseInfo
+    {
+        return new CaseInfo(definition: new CaseDefinition(name: 'RevoltCase', type: 'test'));
+    }
+}
diff --git a/bridge/revolt/tests/suites.php b/bridge/revolt/tests/suites.php
new file mode 100644
index 0000000..8829cb6
--- /dev/null
+++ b/bridge/revolt/tests/suites.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+use Testo\Application\Config\FinderConfig;
+use Testo\Application\Config\SuiteConfig;
+
+/**
+ * Test suites for the Revolt bridge.
+ */
+return [
+    new SuiteConfig(
+        name: 'Revolt/Self',
+        location: new FinderConfig(
+            include: [__DIR__ . '/Self'],
+        ),
+    ),
+    new SuiteConfig(
+        name: 'Revolt/Unit',
+        location: new FinderConfig(
+            include: [__DIR__ . '/Unit'],
+        ),
+    ),
+];
diff --git a/composer.json b/composer.json
index d87e03e..9ad2038 100644
--- a/composer.json
+++ b/composer.json
@@ -62,6 +62,7 @@
         "testo/bridge-infection": "^0.1.8",
         "testo/bridge-mockery": "^0.1.1",
         "testo/bridge-rector": "^0.2.0",
+        "testo/bridge-revolt": "^0.1",
         "testo/facade": "^0.1.1"
     },
     "suggest": {
@@ -74,14 +75,18 @@
     "autoload": {
         "psr-4": {
             "Testo\\": "core/",
-            "Internal\\Container\\": "internal/container/src"
+            "Internal\\Container\\": "internal/container/src",
+            "Internal\\Fiber\\": "internal/fiber/src"
         }
     },
     "replace": {
-        "internal/container": "*"
+        "internal/container": "*",
+        "internal/fiber": "*"
     },
     "autoload-dev": {
         "psr-4": {
+            "Internal\\Container\\Tests\\": "internal/container/tests/",
+            "Internal\\Fiber\\Tests\\": "internal/fiber/tests/",
             "Tests\\PhpUnit\\": "tests/PhpUnit/",
             "Tests\\": "tests/",
             "Tests\\Assert\\": "plugin/assert/tests/",
@@ -89,6 +94,7 @@
             "Tests\\Bench\\": "plugin/bench/tests/",
             "Tests\\Bridge\\Mockery\\": "bridge/mockery/tests/",
             "Tests\\Bridge\\Rector\\": "bridge/rector/tests/",
+            "Tests\\Bridge\\Revolt\\": "bridge/revolt/tests/",
             "Tests\\Bridge\\SymfonyConsole\\": "bridge/symfony-console/tests/",
             "Tests\\Codecov\\": "plugin/codecov/tests/",
             "Tests\\Convention\\": "plugin/convention/tests/",
@@ -136,6 +142,7 @@
                     "testo/bridge-infection": "0.1.x-dev",
                     "testo/bridge-mockery": "0.1.x-dev",
                     "testo/bridge-rector": "0.2.x-dev",
+                    "testo/bridge-revolt": "0.1.x-dev",
                     "testo/bridge-symfony-console": "0.1.x-dev"
                 }
             }
diff --git a/core/Application/Internal/Messenger/MutableContainer.php b/core/Application/Internal/Messenger/MutableContainer.php
deleted file mode 100644
index f712ebb..0000000
--- a/core/Application/Internal/Messenger/MutableContainer.php
+++ /dev/null
@@ -1,19 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Testo\Application\Internal\Messenger;
-
-use Testo\Application\Internal\MessengerHub;
-
-/**
- * Helps {@see MessengerHub} to be readonly to not to be cloned on {@see Container::scope()}.
- *
- * @internal
- */
-final class MutableContainer
-{
-    public function __construct(
-        public State $state,
-    ) {}
-}
diff --git a/core/Application/Internal/Messenger/State.php b/core/Application/Internal/Messenger/State.php
index 86f0013..c236f06 100644
--- a/core/Application/Internal/Messenger/State.php
+++ b/core/Application/Internal/Messenger/State.php
@@ -6,6 +6,7 @@
 
 use Internal\Destroy\Destroyable;
 use Psr\EventDispatcher\EventDispatcherInterface;
+use Testo\Core\Context\TestIdentity;
 use Testo\Core\Log\Message;
 use Testo\Event\Message\MessageReceived;
 
@@ -44,6 +45,7 @@ public function __construct(
         private readonly EventDispatcherInterface $dispatcher,
         private readonly ?self $parent = null,
         private readonly bool $holdEvents = false,
+        private readonly ?TestIdentity $identity = null,
     ) {}
 
     /**
@@ -77,7 +79,8 @@ public function getMessages(): array
 
     public function fork(bool $holdEvents = false): self
     {
-        return new self($this->dispatcher, $this, $holdEvents);
+        # A fork belongs to the same test as its parent, so it inherits the parent's identity.
+        return new self($this->dispatcher, $this, $holdEvents, $this->identity);
     }
 
     #[\Override]
@@ -114,7 +117,7 @@ private function dispatch(Message $message): void
     {
         $this->suspended = true;
         try {
-            $this->dispatcher->dispatch(new MessageReceived($message));
+            $this->dispatcher->dispatch(new MessageReceived($message, $this->identity));
         } finally {
             $this->suspended = false;
         }
diff --git a/core/Application/Internal/MessengerHub.php b/core/Application/Internal/MessengerHub.php
index a752e40..35d4c4a 100644
--- a/core/Application/Internal/MessengerHub.php
+++ b/core/Application/Internal/MessengerHub.php
@@ -5,10 +5,11 @@
 namespace Testo\Application\Internal;
 
 use Psr\EventDispatcher\EventDispatcherInterface;
+use Internal\Fiber\FiberLocal;
 use Testo\Application\Internal\Messenger\State;
-use Testo\Application\Internal\Messenger\MutableContainer;
 use Testo\Common\Messenger;
 use Testo\Common\Messenger\Channel;
+use Testo\Core\Context\TestIdentity;
 use Testo\Core\Log\Level;
 use Testo\Core\Log\Message;
 use Testo\Core\Log\MessageLog;
@@ -20,16 +21,21 @@
  * the state/scope model of {@see \Internal\Container\ObjectContainer}: each scope owns an
  * isolated message buffer, while the {@see MessageReceived} event stream stays global.
  *
+ * The active {@see State} is kept in a {@see FiberLocal} so a scope entered inside a test fiber stays
+ * isolated to that fiber: while several tests interleave on one event loop, each reads its own buffer
+ * across every switch, with no swapping at the suspension boundary.
+ *
  * @internal
  */
 final readonly class MessengerHub implements Messenger
 {
-    private MutableContainer $state;
+    /** @var FiberLocal<State> */
+    private FiberLocal $current;
 
     public function __construct(
         private EventDispatcherInterface $eventDispatcher,
     ) {
-        $this->state = new MutableContainer(new State($this->eventDispatcher));
+        $this->current = new FiberLocal(new State($this->eventDispatcher));
     }
 
     #[\Override]
@@ -37,8 +43,7 @@ public function log(string $channel, string $content, Level $level = Level::Info
     {
         // The active state records the message and announces it (or holds the event, in a holdEvents
         // fork, until commit); it also guards against avalanche recursion during dispatch.
-        /** @psalm-suppress ArgumentTypeCoercion */
-        $this->state->state->record(new Message(\microtime(true), $channel, $level, $content, $context));
+        $this->current->get()->record(new Message(\microtime(true), $channel, $level, $content, $context));
     }
 
     #[\Override]
@@ -48,81 +53,27 @@ public function channel(string $name): Channel
     }
 
     #[\Override]
-    public function scope(\Closure $scope): mixed
+    public function scope(\Closure $scope, ?TestIdentity $identity = null): mixed
     {
-        $old = $this->state->state;
-        $new = new State($this->eventDispatcher);
-        try {
-            $this->state->state = $new;
-            if (\Fiber::getCurrent() === null) {
-                return $scope($this);
-            }
-
-            // Wrap scope into a fiber so the parent state is restored across suspensions.
-            $self = $this;
-            $fiber = new \Fiber(static fn() => $scope($self));
-            $value = $fiber->start();
-            while (!$fiber->isTerminated()) {
-                $this->state->state = $old;
-                try {
-                    $resume = \Fiber::suspend($value);
-                } catch (\Throwable $e) {
-                    $this->state->state = $new;
-                    $value = $fiber->throw($e);
-                    continue;
-                }
-
-                $this->state->state = $new;
-                $value = $fiber->resume($resume);
-            }
-
-            return $fiber->getReturn();
-        } finally {
-            $this->state->state = $old;
-            $new->destroy();
-        }
+        // A test scope carries the test's identity, so every MessageReceived dispatched from within it
+        // is stamped with that test — the seam that keeps interleaving tests' output attributable.
+        $new = new State($this->eventDispatcher, identity: $identity);
+        return $this->current->scope($new, fn(): mixed => $scope($this), $new->destroy(...));
     }
 
     #[\Override]
     public function fork(\Closure $fork, bool $holdEvents = false): mixed
     {
-        $old = $this->state->state;
-        $new = $old->fork($holdEvents);
-        try {
-            $this->state->state = $new;
-            if (\Fiber::getCurrent() === null) {
-                return $fork($new->commit(...));
-            }
-
-            // Wrap the fork into a fiber so the parent state is restored across suspensions.
-            $fiber = new \Fiber(static fn() => $fork($new->commit(...)));
-            $value = $fiber->start();
-            while (!$fiber->isTerminated()) {
-                $this->state->state = $old;
-                try {
-                    $resume = \Fiber::suspend($value);
-                } catch (\Throwable $e) {
-                    $this->state->state = $new;
-                    $value = $fiber->throw($e);
-                    continue;
-                }
-
-                $this->state->state = $new;
-                $value = $fiber->resume($resume);
-            }
-
-            return $fiber->getReturn();
-        } finally {
-            // Restore the parent, but do NOT destroy the fork: the `$commit` callable may be invoked
-            // after this returns (the caller decides to keep/drop the branch only once it sees the
-            // result). commit() clears the fork's own buffer; an abandoned fork is freed by GC.
-            $this->state->state = $old;
-        }
+        // A fork is a child branch on top of the active state. No destroy: the `$commit` callable may be
+        // invoked after this returns (the caller keeps/drops the branch once it sees the result); commit()
+        // clears the fork's own buffer, and an abandoned fork is freed by GC.
+        $new = $this->current->get()->fork($holdEvents);
+        return $this->current->scope($new, static fn(): mixed => $fork($new->commit(...)));
     }
 
     #[\Override]
     public function getMessages(): MessageLog
     {
-        return new MessageLog($this->state->state->getMessages());
+        return new MessageLog($this->current->get()->getMessages());
     }
 }
diff --git a/core/Common/Messenger.php b/core/Common/Messenger.php
index 58cd240..3ae90bd 100644
--- a/core/Common/Messenger.php
+++ b/core/Common/Messenger.php
@@ -4,6 +4,7 @@
 
 namespace Testo\Common;
 
+use Testo\Core\Context\TestIdentity;
 use Testo\Core\Log\Level;
 use Testo\Core\Log\Message;
 use Testo\Core\Log\MessageLog;
@@ -80,11 +81,16 @@ public function channel(string $name): Channel;
      * inside the closure observes only what was written within it. Fiber-aware: the parent state
      * is restored across suspension points.
      *
+     * When an `$identity` is given, every {@see MessageReceived} dispatched from within the scope is
+     * stamped with it, so a consumer can attribute the message to that test even while other tests
+     * interleave their output on the same stream.
+     *
      * @template T
      * @param \Closure(self): T $scope
+     * @param TestIdentity|null $identity Test this scope's messages belong to, if any.
      * @return T
      */
-    public function scope(\Closure $scope): mixed;
+    public function scope(\Closure $scope, ?TestIdentity $identity = null): mixed;
 
     /**
      * Run the given closure within a fork: a mergeable child branch of the active scope.
diff --git a/core/Core/Context/TestIdentity.php b/core/Core/Context/TestIdentity.php
new file mode 100644
index 0000000..4d9be9a
--- /dev/null
+++ b/core/Core/Context/TestIdentity.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Testo\Core\Context;
+
+/**
+ * Stable identity of a single test within a run.
+ *
+ * Distinguishes one running test from another — notably when tests execute concurrently (fibers, a real
+ * event loop) and their lifecycle events and output interleave on a single stream. Reporters use it to
+ * attribute output and lifecycle messages to the right test instead of guessing from ordering.
+ *
+ * For now it carries only a random numeric id; it may grow more fields later.
+ *
+ * @api
+ */
+final readonly class TestIdentity
+{
+    public function __construct(
+        public int $id,
+    ) {}
+
+    /**
+     * Mint a fresh identity with a random id.
+     */
+    public static function generate(): self
+    {
+        return new self(\random_int(1, \PHP_INT_MAX));
+    }
+}
diff --git a/core/Core/Context/TestInfo.php b/core/Core/Context/TestInfo.php
index 96edb18..fbdbf30 100644
--- a/core/Core/Context/TestInfo.php
+++ b/core/Core/Context/TestInfo.php
@@ -16,10 +16,16 @@
 {
     use Attributed;
 
+    /**
+     * Identity of this running test, used to tell tests apart when their events and output interleave.
+     */
+    public TestIdentity $identity;
+
     /**
      * @param non-empty-string $name
      * @param array<array-key, mixed> $arguments Arguments to pass to the test method.
      * @param array<non-empty-string, mixed> $attributes
+     * @param TestIdentity|null $identity Identity to carry; a fresh random one is minted when omitted.
      */
     public function __construct(
         public string $name,
@@ -27,7 +33,10 @@ public function __construct(
         public TestDefinition $testDefinition,
         public array $arguments = [],
         public array $attributes = [],
-    ) {}
+        ?TestIdentity $identity = null,
+    ) {
+        $this->identity = $identity ?? TestIdentity::generate();
+    }
 
     public function with(
         ?array $arguments = null,
@@ -38,6 +47,7 @@ public function with(
             testDefinition: $this->testDefinition,
             arguments: $arguments ?? $this->arguments,
             attributes: $this->attributes,
+            identity: $this->identity,
         );
     }
 }
diff --git a/core/Event/Message/MessageReceived.php b/core/Event/Message/MessageReceived.php
index 1d885b4..1e21cd6 100644
--- a/core/Event/Message/MessageReceived.php
+++ b/core/Event/Message/MessageReceived.php
@@ -4,6 +4,7 @@
 
 namespace Testo\Event\Message;
 
+use Testo\Core\Context\TestIdentity;
 use Testo\Core\Log\Message;
 
 /**
@@ -18,7 +19,13 @@
  */
 final readonly class MessageReceived
 {
+    /**
+     * @param TestIdentity|null $identity Identity of the test the message was recorded for, or `null`
+     *        when it belongs to no test (suite/case setup, output between tests). Lets consumers
+     *        attribute interleaved output to the right test instead of guessing from ordering.
+     */
     public function __construct(
         public Message $message,
+        public ?TestIdentity $identity = null,
     ) {}
 }
diff --git a/core/Output/Teamcity/Teamcity/Formatter.php b/core/Output/Teamcity/Teamcity/Formatter.php
index b9af582..379c1f4 100644
--- a/core/Output/Teamcity/Teamcity/Formatter.php
+++ b/core/Output/Teamcity/Teamcity/Formatter.php
@@ -27,9 +27,11 @@ private function __construct() {}
      * @param \ReflectionClass<object>|null $caseReflection Concrete (runtime) case class, used to
      *        attribute a method-backed suite (a DataProvider batch) to the subclass rather than the
      *        method's declaring class. Ignored when `$reflection` is a class.
+     * @param non-empty-string|null $flowId Flow this suite belongs to; groups its messages apart from
+     *        other flows running concurrently on the same stream.
      * @return non-empty-string
      */
-    public static function suiteStarted(string $name, null|\ReflectionClass|\ReflectionFunctionAbstract $reflection = null, ?\ReflectionClass $caseReflection = null): string
+    public static function suiteStarted(string $name, null|\ReflectionClass|\ReflectionFunctionAbstract $reflection = null, ?\ReflectionClass $caseReflection = null, ?string $flowId = null): string
     {
         $attributes = ['name' => $name];
 
@@ -40,6 +42,8 @@ public static function suiteStarted(string $name, null|\ReflectionClass|\Reflect
             $locationHint !== null and $attributes['locationHint'] = $locationHint;
         }
 
+        $flowId !== null and $attributes['flowId'] = $flowId;
+
         return self::formatMessage('testSuiteStarted', $attributes);
     }
 
@@ -47,11 +51,16 @@ public static function suiteStarted(string $name, null|\ReflectionClass|\Reflect
      * Formats a test suite finished message.
      *
      * @param non-empty-string $name Suite name
+     * @param non-empty-string|null $flowId Flow this suite belongs to.
      * @return non-empty-string
      */
-    public static function suiteFinished(string $name): string
+    public static function suiteFinished(string $name, ?string $flowId = null): string
     {
-        return self::formatMessage('testSuiteFinished', ['name' => $name]);
+        $attributes = ['name' => $name];
+
+        $flowId !== null and $attributes['flowId'] = $flowId;
+
+        return self::formatMessage('testSuiteFinished', $attributes);
     }
 
     /**
@@ -65,9 +74,11 @@ public static function suiteFinished(string $name): string
      *        the TeamCity `metainfo` attribute. Omitted when `null`.
      * @param \ReflectionClass<object>|null $caseReflection Concrete (runtime) case class, used to
      *        attribute an inherited test to the subclass rather than the method's declaring class.
+     * @param non-empty-string|null $flowId Flow this test belongs to; keeps its messages grouped apart
+     *        from other tests running concurrently on the same stream.
      * @return non-empty-string
      */
-    public static function testStarted(string $name, bool $captureStandardOutput = false, ?\ReflectionFunctionAbstract $reflection = null, ?string $locationSuffix = null, ?string $description = null, ?\ReflectionClass $caseReflection = null): string
+    public static function testStarted(string $name, bool $captureStandardOutput = false, ?\ReflectionFunctionAbstract $reflection = null, ?string $locationSuffix = null, ?string $description = null, ?\ReflectionClass $caseReflection = null, ?string $flowId = null): string
     {
         $attributes = ['name' => $name];
 
@@ -79,6 +90,7 @@ public static function testStarted(string $name, bool $captureStandardOutput = f
         }
 
         $description !== null and $attributes['metainfo'] = $description;
+        $flowId !== null and $attributes['flowId'] = $flowId;
 
         return self::formatMessage('testStarted', $attributes);
     }
@@ -88,13 +100,15 @@ public static function testStarted(string $name, bool $captureStandardOutput = f
      *
      * @param non-empty-string $name Test name
      * @param int<0, max>|null $duration Duration in milliseconds
+     * @param non-empty-string|null $flowId Flow this test belongs to.
      * @return non-empty-string
      */
-    public static function testFinished(string $name, ?int $duration = null): string
+    public static function testFinished(string $name, ?int $duration = null, ?string $flowId = null): string
     {
         $attributes = ['name' => $name];
 
         $duration !== null and $attributes['duration'] = (string) $duration;
+        $flowId !== null and $attributes['flowId'] = $flowId;
 
         return self::formatMessage('testFinished', $attributes);
     }
@@ -108,6 +122,7 @@ public static function testFinished(string $name, ?int $duration = null): string
      * @param non-empty-string|null $type Comparison type for diff display (e.g., 'comparisonFailure')
      * @param non-empty-string|null $expected Expected value for diff
      * @param non-empty-string|null $actual Actual value for diff
+     * @param non-empty-string|null $flowId Flow this test belongs to.
      * @return non-empty-string
      */
     public static function testFailed(
@@ -117,6 +132,7 @@ public static function testFailed(
         ?string $type = null,
         ?string $expected = null,
         ?string $actual = null,
+        ?string $flowId = null,
     ): string {
         $attributes = [
             'name' => $name,
@@ -127,6 +143,7 @@ public static function testFailed(
         $type !== null and $attributes['type'] = $type;
         $expected !== null and $attributes['expected'] = $expected;
         $actual !== null and $attributes['actual'] = $actual;
+        $flowId !== null and $attributes['flowId'] = $flowId;
 
         return self::formatMessage('testFailed', $attributes);
     }
@@ -136,13 +153,15 @@ public static function testFailed(
      *
      * @param non-empty-string $name Test name
      * @param non-empty-string $message Optional skip reason
+     * @param non-empty-string|null $flowId Flow this test belongs to.
      * @return non-empty-string
      */
-    public static function testIgnored(string $name, string $message = ''): string
+    public static function testIgnored(string $name, string $message = '', ?string $flowId = null): string
     {
         $attributes = ['name' => $name];
 
         $message !== '' and $attributes['message'] = $message;
+        $flowId !== null and $attributes['flowId'] = $flowId;
 
         return self::formatMessage('testIgnored', $attributes);
     }
@@ -154,10 +173,13 @@ public static function testIgnored(string $name, string $message = ''): string
      * @param non-empty-string $output Standard output content
      * @param array<non-empty-string, string> $attributes Extra attributes (e.g. `channel`, `level`)
      *        for consumers that understand them; standard TeamCity parsers ignore unknown ones.
+     * @param non-empty-string|null $flowId Flow the emitting test belongs to.
      * @return non-empty-string
      */
-    public static function testStdOut(string $name, string $output, array $attributes = []): string
+    public static function testStdOut(string $name, string $output, array $attributes = [], ?string $flowId = null): string
     {
+        $flowId !== null and $attributes['flowId'] = $flowId;
+
         return self::formatMessage('testStdOut', [
             'name' => $name,
             'out' => $output,
@@ -171,10 +193,13 @@ public static function testStdOut(string $name, string $output, array $attribute
      * @param non-empty-string $output Standard error content
      * @param array<non-empty-string, string> $attributes Extra attributes (e.g. `channel`, `level`)
      *        for consumers that understand them; standard TeamCity parsers ignore unknown ones.
+     * @param non-empty-string|null $flowId Flow the emitting test belongs to.
      * @return non-empty-string
      */
-    public static function testStdErr(string $name, string $output, array $attributes = []): string
+    public static function testStdErr(string $name, string $output, array $attributes = [], ?string $flowId = null): string
     {
+        $flowId !== null and $attributes['flowId'] = $flowId;
+
         return self::formatMessage('testStdErr', [
             'name' => $name,
             'out' => $output,
diff --git a/core/Output/Teamcity/Teamcity/TeamcityLogger.php b/core/Output/Teamcity/Teamcity/TeamcityLogger.php
index 527e991..ffe75be 100644
--- a/core/Output/Teamcity/Teamcity/TeamcityLogger.php
+++ b/core/Output/Teamcity/Teamcity/TeamcityLogger.php
@@ -12,6 +12,7 @@
 use Testo\Core\Context\CaseResult;
 use Testo\Core\Context\SuiteInfo;
 use Testo\Core\Context\SuiteResult;
+use Testo\Core\Context\TestIdentity;
 use Testo\Core\Context\TestInfo;
 use Testo\Core\Context\TestResult;
 use Testo\Core\Log\Message;
@@ -45,6 +46,17 @@ public function __construct($output = null)
         $this->output = $output ?? \STDOUT;
     }
 
+    /**
+     * TeamCity `flowId` for a test: distinct concurrent tests get distinct flows, so their interleaved
+     * `testStarted`/output/`testFinished` messages stay grouped instead of overlapping on one stream.
+     *
+     * @return non-empty-string
+     */
+    public static function flowId(TestIdentity $identity): string
+    {
+        return (string) $identity->id;
+    }
+
     /**
      * Formats a throwable into a detailed string with class, message, file, line, and stack trace.
      */
@@ -125,7 +137,12 @@ public function suiteFinishedFromInfo(SuiteInfo $info): void
      */
     public function batchStartedFromInfo(TestInfo $info): void
     {
-        $this->publish(Formatter::suiteStarted($info->name, $info->testDefinition->reflection, $info->caseInfo->definition->reflection));
+        $this->publish(Formatter::suiteStarted(
+            $info->name,
+            $info->testDefinition->reflection,
+            $info->caseInfo->definition->reflection,
+            self::flowId($info->identity),
+        ));
     }
 
     /**
@@ -133,7 +150,7 @@ public function batchStartedFromInfo(TestInfo $info): void
      */
     public function batchFinishedFromInfo(TestInfo $info): void
     {
-        $this->publish(Formatter::suiteFinished($info->name));
+        $this->publish(Formatter::suiteFinished($info->name, self::flowId($info->identity)));
     }
 
     /**
@@ -217,6 +234,7 @@ public function testStartedFromInfo(TestInfo $info, bool $captureStandardOutput
             $locationSuffix,
             $description,
             $info->caseInfo->definition->reflection,
+            self::flowId($info->identity),
         ));
     }
 
@@ -227,7 +245,7 @@ public function testStartedFromInfo(TestInfo $info, bool $captureStandardOutput
      */
     public function testFinishedFromInfo(TestInfo $info, ?int $duration = null): void
     {
-        $this->publish(Formatter::testFinished($info->name, $duration));
+        $this->publish(Formatter::testFinished($info->name, $duration, self::flowId($info->identity)));
     }
 
     /**
@@ -252,6 +270,7 @@ public function testFailedFromResult(TestResult $result): void
                 type: $isComparison ? 'comparisonFailure' : null,
                 expected: $isComparison ? $failure->getExpectedAsString() : null,
                 actual: $isComparison ? $failure->getActualAsString() : null,
+                flowId: self::flowId($result->info->identity),
             ),
         );
     }
@@ -276,8 +295,10 @@ public function testIgnoredFromInfo(TestInfo $info, string $message = ''): void
      * `testFinished` to nest correctly.
      *
      * @param non-empty-string $name Test name the message belongs to.
+     * @param non-empty-string|null $flowId Flow of the test the message belongs to, so interleaved
+     *        output stays grouped with the right test.
      */
-    public function logMessage(string $name, Message $message): void
+    public function logMessage(string $name, Message $message, ?string $flowId = null): void
     {
         if ($message->content === '') {
             return;
@@ -291,8 +312,8 @@ public function logMessage(string $name, Message $message): void
         ];
 
         $this->publish($message->channel === self::CHANNEL_STDERR
-            ? Formatter::testStdErr($name, $message->content, $attributes)
-            : Formatter::testStdOut($name, $message->content, $attributes));
+            ? Formatter::testStdErr($name, $message->content, $attributes, $flowId)
+            : Formatter::testStdOut($name, $message->content, $attributes, $flowId));
     }
 
     /**
@@ -383,7 +404,7 @@ private function handlePassedTest(TestResult $result, ?int $duration, ?string $o
     {
         $name = $overrideName ?? $result->info->name;
 
-        $this->publish(Formatter::testFinished($name, $duration));
+        $this->publish(Formatter::testFinished($name, $duration, self::flowId($result->info->identity)));
     }
 
     /**
@@ -394,8 +415,9 @@ private function handlePassedTest(TestResult $result, ?int $duration, ?string $o
     private function handleSkippedTest(TestResult $result, ?int $duration, ?string $overrideName = null): void
     {
         $name = $overrideName ?? $result->info->name;
-        $this->publish(Formatter::testIgnored($name));
-        $this->publish(Formatter::testFinished($name, $duration));
+        $flowId = self::flowId($result->info->identity);
+        $this->publish(Formatter::testIgnored($name, flowId: $flowId));
+        $this->publish(Formatter::testFinished($name, $duration, $flowId));
     }
 
     /**
@@ -406,8 +428,9 @@ private function handleSkippedTest(TestResult $result, ?int $duration, ?string $
     private function handleCancelledTest(TestResult $result, ?int $duration, ?string $overrideName = null): void
     {
         $name = $overrideName ?? $result->info->name;
-        $this->publish(Formatter::testIgnored($name, 'Test cancelled'));
-        $this->publish(Formatter::testFinished($name, $duration));
+        $flowId = self::flowId($result->info->identity);
+        $this->publish(Formatter::testIgnored($name, 'Test cancelled', $flowId));
+        $this->publish(Formatter::testFinished($name, $duration, $flowId));
     }
 
     /**
@@ -426,6 +449,7 @@ private function handleFailedTest(TestResult $result, ?int $duration, ?string $o
             : '';
 
         $isComparison = $failure instanceof ComparisonFailure;
+        $flowId = self::flowId($result->info->identity);
 
         $this->publish(
             Formatter::testFailed(
@@ -435,9 +459,10 @@ private function handleFailedTest(TestResult $result, ?int $duration, ?string $o
                 type: $isComparison ? 'comparisonFailure' : null,
                 expected: $isComparison ? $failure->getExpectedAsString() : null,
                 actual: $isComparison ? $failure->getActualAsString() : null,
+                flowId: $flowId,
             ),
         );
-        $this->publish(Formatter::testFinished($name, $duration));
+        $this->publish(Formatter::testFinished($name, $duration, $flowId));
     }
 
     /**
@@ -452,15 +477,17 @@ private function handleAbortedTest(TestResult $result, ?int $duration, ?string $
         $details = $result->failure !== null
             ? self::formatThrowable($result->failure, $result->info->testDefinition->reflection)
             : '';
+        $flowId = self::flowId($result->info->identity);
 
         $this->publish(
             Formatter::testFailed(
                 $name,
                 'Test aborted',
                 $details,
+                flowId: $flowId,
             ),
         );
-        $this->publish(Formatter::testFinished($name, $duration));
+        $this->publish(Formatter::testFinished($name, $duration, $flowId));
     }
 
     /**
@@ -471,14 +498,16 @@ private function handleAbortedTest(TestResult $result, ?int $duration, ?string $
     private function handleRiskyTest(TestResult $result, ?int $duration, ?string $overrideName = null): void
     {
         $name = $overrideName ?? $result->info->name;
+        $flowId = self::flowId($result->info->identity);
 
         $this->publish(
             Formatter::testStdOut(
                 $name,
                 "\nWarning: This test has been marked as risky",
+                flowId: $flowId,
             ),
         );
-        $this->publish(Formatter::testFinished($name, $duration));
+        $this->publish(Formatter::testFinished($name, $duration, $flowId));
     }
 
     /**
diff --git a/core/Output/Teamcity/TeamcityPlugin.php b/core/Output/Teamcity/TeamcityPlugin.php
index 8fa9b25..01c4980 100644
--- a/core/Output/Teamcity/TeamcityPlugin.php
+++ b/core/Output/Teamcity/TeamcityPlugin.php
@@ -27,27 +27,32 @@
 final class TeamcityPlugin implements PluginConfigurator
 {
     /**
-     * Tracks whether we're inside a DataProvider batch.
+     * Ids of the tests currently inside a DataProvider batch.
      *
-     * @var array<non-empty-string, bool>
+     * Keyed by {@see \Testo\Core\Context\TestIdentity::$id} so concurrently running tests are tracked
+     * independently — a single scalar would be clobbered the moment two tests interleave.
+     *
+     * @var array<int, bool>
      */
     private array $isBatch = [];
 
     /**
-     * Name of the in-flight test/data set that streamed {@see MessageReceived} output is attributed
-     * to. `null` when no test is running (output between tests is dropped).
+     * Name of the in-flight test/data set that streamed {@see MessageReceived} output is attributed to,
+     * per running test id. A test with no entry is not running (its output is dropped).
      *
-     * @var non-empty-string|null
+     * @var array<int, non-empty-string>
      */
-    private ?string $currentName = null;
+    private array $currentName = [];
 
     /**
-     * A regular (non-DataProvider) test whose `testStarted` has not been emitted yet. It is emitted
-     * lazily on the first message (so output can stream in real time), or at pipeline finish if the
-     * test produced no output. `null` once `testStarted` has been emitted (or for data sets, which
-     * emit it eagerly).
+     * Regular (non-DataProvider) tests whose `testStarted` has not been emitted yet, per test id. Emitted
+     * lazily on the first message (so output streams in real time), or at pipeline finish if the test
+     * produced no output. Dropped once `testStarted` has been emitted (or for data sets, which emit it
+     * eagerly).
+     *
+     * @var array<int, TestInfo>
      */
-    private ?TestInfo $pendingStart = null;
+    private array $pendingStart = [];
 
     private readonly TeamcityLogger $logger;
 
@@ -89,18 +94,12 @@ public function configure(Container $container): void
         $listeners->addListener(TestSuiteFinished::class, $this->onTestSuiteFinished(...));
     }
 
-    private static function getId(TestInfo $testInfo): string
-    {
-        return \spl_object_hash($testInfo->testDefinition);
-    }
-
     /**
-     * Clears the current-test attribution so output emitted outside any test is dropped.
+     * Clears one test's attribution once it is done, so later output outside any test is dropped.
      */
-    private function resetCurrent(): void
+    private function resetCurrent(int $id): void
     {
-        $this->currentName = null;
-        $this->pendingStart = null;
+        unset($this->currentName[$id], $this->pendingStart[$id]);
     }
 
     private function onSessionStarting(SessionStarting $event): void
@@ -117,62 +116,68 @@ private function onSessionFinished(SessionFinished $event): void
 
     private function onMessageReceived(MessageReceived $event): void
     {
-        // No test in flight — output between tests is not attributable, so drop it. Internal errors on
-        // the dedicated stderr channel are the exception: surface them as a standalone message instead.
-        if ($this->currentName === null) {
+        $identity = $event->identity;
+
+        // No attributable test — the message belongs to none (suite/case setup, output between tests),
+        // or its test is not tracked here. Drop it; internal errors on the dedicated stderr channel are
+        // the exception and are surfaced as a standalone message instead.
+        if ($identity === null || !isset($this->currentName[$identity->id])) {
             $event->message->channel === Messenger::CHANNEL_STDERR
                 and $this->logger->logStandaloneMessage($event->message);
             return;
         }
 
+        $id = $identity->id;
+
         // Lazily emit testStarted for a regular test on its first output, so it streams in real time.
-        if ($this->pendingStart !== null) {
-            $this->logger->testStartedFromInfo($this->pendingStart);
-            $this->pendingStart = null;
+        if (isset($this->pendingStart[$id])) {
+            $this->logger->testStartedFromInfo($this->pendingStart[$id]);
+            unset($this->pendingStart[$id]);
         }
 
-        $this->logger->logMessage($this->currentName, $event->message);
+        $this->logger->logMessage($this->currentName[$id], $event->message, TeamcityLogger::flowId($identity));
     }
 
     private function onTestPipelineStarting(TestPipelineStarting $event): void
     {
         // Assume a regular test: attribute output to it and keep testStarted pending until output
         // arrives. If it turns out to be a DataProvider batch, onTestBatchStarting clears this.
-        $this->currentName = $event->testInfo->name;
-        $this->pendingStart = $event->testInfo;
+        $id = $event->testInfo->identity->id;
+        $this->currentName[$id] = $event->testInfo->name;
+        $this->pendingStart[$id] = $event->testInfo;
     }
 
     private function onTestPipelineFinished(TestPipelineFinished $event): void
     {
         // Check if this test was inside a DataProvider batch
-        $id = self::getId($event->testInfo);
+        $id = $event->testInfo->identity->id;
         if (isset($this->isBatch[$id])) {
             // DataProvider test - already handled in batch events
             unset($this->isBatch[$id]);
-            $this->resetCurrent();
+            $this->resetCurrent($id);
             return;
         }
 
         // Regular test: testStarted was emitted lazily on first output; if there was none, emit now.
-        if ($this->pendingStart !== null) {
-            $this->logger->testStartedFromInfo($this->pendingStart);
-            $this->pendingStart = null;
+        if (isset($this->pendingStart[$id])) {
+            $this->logger->testStartedFromInfo($this->pendingStart[$id]);
+            unset($this->pendingStart[$id]);
         }
 
         $duration = (int) $event->testResult->getAttribute('duration');
         $this->logger->handleSingleTestResult($event->testResult, $duration);
-        $this->resetCurrent();
+        $this->resetCurrent($id);
     }
 
     private function onTestBatchStarting(TestBatchStarting $event): void
     {
         // Mark that we're inside a batch
-        $id = self::getId($event->testInfo);
+        $id = $event->testInfo->identity->id;
         $this->isBatch[$id] = true;
 
         // It's a DataProvider, not a single test: drop the pending single-test start; data sets
         // emit their own testStarted and own the current attribution.
-        $this->resetCurrent();
+        $this->resetCurrent($id);
 
         // For DataProvider tests, start a test suite (wraps all data sets)
         $this->logger->batchStartedFromInfo($event->testInfo);
@@ -198,9 +203,12 @@ private function onTestDataSetStarting(TestDataSetStarting $event): void
             locationSuffix: $locationSuffix,
         );
 
-        // testStarted already emitted eagerly; stream this data set's output to it in real time.
-        $this->currentName = $name;
-        $this->pendingStart = null;
+        // testStarted already emitted eagerly; stream this data set's output to it in real time. Data
+        // sets of one provider share the batch's identity and run sequentially, so one current-name
+        // entry per id is unambiguous.
+        $id = $event->testInfo->identity->id;
+        $this->currentName[$id] = $name;
+        unset($this->pendingStart[$id]);
     }
 
     private function onTestDataSetFinished(TestDataSetFinished $event): void
@@ -211,7 +219,7 @@ private function onTestDataSetFinished(TestDataSetFinished $event): void
         $name = "Dataset #{$prefix}{$event->datasetIndex} [$event->datasetKey]";
 
         $this->logger->handleSingleTestResult($event->testResult, $duration, overrideName: $name);
-        $this->resetCurrent();
+        $this->resetCurrent($event->testInfo->identity->id);
     }
 
     private function onTestCaseStarting(TestCaseStarting $event): void
diff --git a/core/Pipeline/Internal/OutputInterceptor.php b/core/Pipeline/Internal/OutputInterceptor.php
index c350089..9a293d0 100644
--- a/core/Pipeline/Internal/OutputInterceptor.php
+++ b/core/Pipeline/Internal/OutputInterceptor.php
@@ -45,7 +45,8 @@ public function __construct(
     #[\Override]
     public function runTest(TestInfo $info, callable $next): TestResult
     {
-        # Fork the messenger: everything written during this test lands in an isolated buffer.
+        # Fork the messenger: everything written during this test lands in an isolated buffer, and
+        # every MessageReceived it dispatches is stamped with this test's identity.
         return $this->messenger->scope(static function (Messenger $messenger) use ($info, $next): TestResult {
             $result = $next($info);
 
@@ -54,6 +55,6 @@ public function runTest(TestInfo $info, callable $next): TestResult
             return $messages->isEmpty()
                 ? $result
                 : $result->withMessages($messages);
-        });
+        }, $info->identity);
     }
 }
diff --git a/internal/container/src/ObjectContainer.php b/internal/container/src/ObjectContainer.php
index 3a23633..ea8ad36 100644
--- a/internal/container/src/ObjectContainer.php
+++ b/internal/container/src/ObjectContainer.php
@@ -5,6 +5,7 @@
 namespace Internal\Container;
 
 use Internal\Container\Interanl\State;
+use Internal\Fiber\FiberLocal;
 
 /**
  * Simple dependency injection container.
@@ -12,98 +13,78 @@
  * Provides service creation and caching with autowiring capabilities.
  * Automatically loads configuration for config classes.
  *
+ * The active {@see State} lives in a {@see FiberLocal} so a scope entered inside a fiber stays isolated to
+ * that fiber: when several fibers interleave on one event loop, each reads its own scoped bindings across
+ * every switch, with no swapping at the suspension boundary.
+ *
  * @internal
  * @psalm-internal Testo\Application
  */
 final class ObjectContainer implements Container
 {
-    private State $state;
+    /** @var FiberLocal<State> */
+    private FiberLocal $current;
 
     public function __construct()
     {
-        $this->state = new State($this);
+        $this->current = new FiberLocal(new State($this));
     }
 
     public function addInflector(Inflector $inflector): void
     {
-        $this->state->addInflector($inflector);
+        $this->current->get()->addInflector($inflector);
     }
 
     #[\Override]
     public function get(string $id, array $arguments = []): object
     {
-        return $this->state->get($id, $arguments);
+        return $this->current->get()->get($id, $arguments);
     }
 
     #[\Override]
     public function has(string $id): bool
     {
-        return $this->state->has($id);
+        return $this->current->get()->has($id);
     }
 
     #[\Override]
     public function set(object $service, ?string $id = null, bool $destroy = false): void
     {
         \assert($id === null || $service instanceof $id, "Service must be instance of {$id}.");
-        $this->state->set($service, $id, $destroy);
+        $this->current->get()->set($service, $id, $destroy);
     }
 
     #[\Override]
     public function make(string $class, array $arguments = []): object
     {
-        return $this->state->make($class, $arguments);
+        return $this->current->get()->make($class, $arguments);
     }
 
     #[\Override]
     public function bind(string $id, \Closure|string|array|null $binding = null): void
     {
-        $this->state->bind($id, $binding);
+        $this->current->get()->bind($id, $binding);
     }
 
     #[\Override]
     public function scope(\Closure $scope): mixed
     {
-        $oldState = $this->state;
-        $newState = $oldState->clone($this);
-        try {
-            $this->state = $newState;
-            if (\Fiber::getCurrent() === null) {
-                return $scope($this);
-            }
-
-            // Wrap scope into fiber
-            $fiber = new \Fiber(static fn(ObjectContainer $c) => $scope($c));
-            $value = $fiber->start($this);
-            while (!$fiber->isTerminated()) {
-                $this->state = $oldState;
-                try {
-                    $resume = \Fiber::suspend($value);
-                } catch (\Throwable $e) {
-                    $this->state = $newState;
-                    $value = $fiber->throw($e);
-                    continue;
-                }
-
-                $this->state = $newState;
-                $value = $fiber->resume($resume);
-            }
-
-            return $fiber->getReturn();
-        } finally {
-            $this->state = $oldState;
-            $newState->destroy();
-        }
+        // Clone the active state into a child scope; FiberLocal binds it to the current fiber only and
+        // restores the parent on exit — even across a real event-loop suspension inside $scope, where the
+        // loop resumes this exact fiber directly. The child state is destroyed after the parent is restored.
+        $new = $this->current->get()->clone($this);
+        return $this->current->scope($new, fn(): mixed => $scope($this), $new->destroy(...));
     }
 
     #[\Override]
     public function destroy(): void
     {
-        $this->state->destroy();
-        unset($this->state);
+        $this->current->get()->destroy();
+        unset($this->current);
     }
 
     public function __clone(): void
     {
-        $this->state = clone $this->state;
+        $this->current = new FiberLocal(clone $this->current->get());
     }
 }
diff --git a/internal/container/tests/Testo/Fibers.php b/internal/container/tests/Testo/Fibers.php
new file mode 100644
index 0000000..5bc550e
--- /dev/null
+++ b/internal/container/tests/Testo/Fibers.php
@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Testo;
+
+/**
+ * Tiny cooperative fiber driver for the container-scope tests — no event loop, just plain fibers.
+ *
+ * {@see runInFiber()} drives one fiber and, for each value it suspends, calls a check that may throw
+ * **back into** the fiber at that suspension point (to probe how a scope behaves when an exception is
+ * injected mid-flight). {@see runSequence()} round-robins several fibers to completion so their scopes
+ * genuinely interleave at each `\Fiber::suspend()`.
+ *
+ * Adapted from Spiral's Core scope fiber tests.
+ *
+ * @internal
+ */
+final class Fibers
+{
+    private function __construct() {}
+
+    /**
+     * Run $callable in a fiber; for each suspended value call $check (which may return a replacement
+     * value or throw it back into the fiber). Returns the fiber's return value.
+     *
+     * @template TReturn
+     * @param callable(): TReturn $callable
+     * @param null|callable(mixed): mixed $check
+     * @return TReturn
+     */
+    public static function runInFiber(callable $callable, ?callable $check = null): mixed
+    {
+        $fiber = new \Fiber($callable);
+        $value = $fiber->start();
+        while (!$fiber->isTerminated()) {
+            if ($check !== null) {
+                try {
+                    $value = $check($value);
+                } catch (\Throwable $e) {
+                    $value = $fiber->throw($e);
+                    continue;
+                }
+            }
+            $value = $fiber->resume($value);
+        }
+
+        return $fiber->getReturn();
+    }
+
+    /**
+     * Start every callable in its own fiber, then round-robin resume them to completion so they
+     * interleave at each `\Fiber::suspend()`. Returns each fiber's return value, keyed by input order.
+     *
+     * @param callable(): mixed ...$callables
+     * @return array<array-key, mixed>
+     */
+    public static function runSequence(callable ...$callables): array
+    {
+        $fibers = [];
+        $results = [];
+        foreach ($callables as $key => $callable) {
+            $fibers[$key] = new \Fiber($callable);
+            $results[$key] = null;
+        }
+
+        foreach ($fibers as $fiber) {
+            $fiber->start();
+        }
+
+        while ($fibers !== []) {
+            foreach ($fibers as $key => $fiber) {
+                if ($fiber->isTerminated()) {
+                    $results[$key] = $fiber->getReturn();
+                    unset($fibers[$key]);
+                    continue;
+                }
+                $fiber->resume();
+            }
+        }
+
+        return $results;
+    }
+}
diff --git a/internal/container/tests/Testo/Loop.php b/internal/container/tests/Testo/Loop.php
new file mode 100644
index 0000000..3db1c20
--- /dev/null
+++ b/internal/container/tests/Testo/Loop.php
@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Testo;
+
+use Revolt\EventLoop;
+
+/**
+ * Minimal Revolt harness for the container-scope tests.
+ *
+ * Runs a body as a coroutine on the process event loop and, from inside it, forces a real
+ * round-trip through the Revolt driver. Deliberately independent of the `testo/async` plugin:
+ * these tests probe how {@see \Internal\Container\ObjectContainer::scope()} behaves under
+ * Revolt — the exact guard/driver interaction the fiber-local migration must fix.
+ *
+ * @internal
+ */
+final class Loop
+{
+    private function __construct() {}
+
+    /**
+     * Run $body as a single coroutine on the Revolt loop; return its value (or rethrow).
+     *
+     * `getSuspension()` is taken on the caller (main) fiber, so `suspend()` runs the loop while
+     * the queued microtask executes $body inside a loop-driven fiber.
+     *
+     * @template T
+     * @param \Closure(): T $body
+     * @return T
+     */
+    public static function run(\Closure $body): mixed
+    {
+        $suspension = EventLoop::getSuspension();
+
+        EventLoop::queue(static function () use ($suspension, $body): void {
+            try {
+                $suspension->resume($body());
+            } catch (\Throwable $e) {
+                $suspension->throw($e);
+            }
+        });
+
+        return $suspension->suspend();
+    }
+
+    /**
+     * Inside a {@see run()} body: yield to the loop and resume on the next tick — a genuine
+     * suspension through the Revolt driver, i.e. the point where a guard that hand-drives the
+     * fiber collides with the driver resuming it.
+     */
+    public static function tick(): void
+    {
+        $suspension = EventLoop::getSuspension();
+        EventLoop::queue(static fn() => $suspension->resume());
+        $suspension->suspend();
+    }
+}
diff --git a/internal/container/tests/Unit/ConcurrentScopesRevoltTest.php b/internal/container/tests/Unit/ConcurrentScopesRevoltTest.php
new file mode 100644
index 0000000..e07fc82
--- /dev/null
+++ b/internal/container/tests/Unit/ConcurrentScopesRevoltTest.php
@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit;
+
+use Internal\Container\ObjectContainer;
+use Internal\Container\Tests\Unit\Stub\ContainerScopeService;
+use Revolt\EventLoop;
+use Testo\Assert;
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Bridge\Revolt\Strategy;
+use Testo\Codecov\Covers;
+use Testo\Lifecycle\BeforeClass;
+use Testo\Test;
+
+/**
+ * Container `scope()` isolation under **concurrent** tests on a real Revolt loop.
+ *
+ * `#[RunInRevolt(Strategy::PerCase)]` launches all three tests at once; they share one {@see ObjectContainer},
+ * each enters its own scope, sets a distinct tag, then awaits a real timer **repeatedly** — re-reading its
+ * scoped instance after every await. The tag must hold across all of them while the other two tests are
+ * genuinely interleaving at their own await points, proving per-fiber container state survives real
+ * event-loop scheduling.
+ */
+#[Test]
+#[RunInRevolt(Strategy::PerCase)]
+#[Covers(ObjectContainer::class)]
+final class ConcurrentScopesRevoltTest
+{
+    private static ObjectContainer $container;
+
+    #[BeforeClass]
+    public static function bootContainer(): void
+    {
+        self::$container = new ObjectContainer();
+    }
+
+    public function firstScopeKeepsItsStateAcrossConcurrentAwaits(): void
+    {
+        self::scopeHoldsTagAcrossAwaits(1);
+    }
+
+    public function secondScopeKeepsItsStateAcrossConcurrentAwaits(): void
+    {
+        self::scopeHoldsTagAcrossAwaits(2);
+    }
+
+    public function thirdScopeKeepsItsStateAcrossConcurrentAwaits(): void
+    {
+        self::scopeHoldsTagAcrossAwaits(3);
+    }
+
+    /**
+     * Enter a scope, tag its {@see ContainerScopeService}, then await a real timer three times, asserting
+     * after each await that the scoped instance still carries this test's own tag.
+     */
+    private static function scopeHoldsTagAcrossAwaits(int $tag): void
+    {
+        self::$container->scope(static function (ObjectContainer $scoped) use ($tag): void {
+            $scoped->get(ContainerScopeService::class)->tag = $tag;
+
+            for ($i = 0; $i < 3; $i++) {
+                $suspension = EventLoop::getSuspension();
+                EventLoop::delay(0.001, static fn() => $suspension->resume());
+                $suspension->suspend();
+
+                Assert::same($scoped->get(ContainerScopeService::class)->tag, $tag);
+            }
+        });
+    }
+}
diff --git a/internal/container/tests/Unit/FiberScopeTest.php b/internal/container/tests/Unit/FiberScopeTest.php
new file mode 100644
index 0000000..35c52e3
--- /dev/null
+++ b/internal/container/tests/Unit/FiberScopeTest.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit;
+
+use Internal\Container\ObjectContainer;
+use Internal\Container\Tests\Testo\Fibers;
+use Internal\Container\Tests\Unit\Stub\ContainerScopeService;
+use Testo\Assert;
+use Testo\Codecov\Covers;
+use Testo\Expect;
+use Testo\Test;
+
+/**
+ * {@see ObjectContainer::scope()} driven by hand through plain fibers — exceptions injected at a
+ * suspension point and many scopes interleaving on one thread.
+ *
+ * Adapted from Spiral's Core scope fiber tests. Assertions run on the test fiber (values are collected
+ * or returned out of the driven fibers), because the assertion collector is itself fiber-local.
+ */
+#[Test]
+#[Covers(ObjectContainer::class)]
+final class FiberScopeTest
+{
+    public function scopeCatchesAnExceptionInjectedAtSuspendAndKeepsItsState(): void
+    {
+        $container = new ObjectContainer();
+
+        $result = Fibers::runInFiber(
+            static fn(): string => $container->scope(static function (ObjectContainer $scoped): string {
+                $scoped->get(ContainerScopeService::class)->tag = 7;
+
+                $out = (string) \Fiber::suspend('foo');
+                try {
+                    $out .= (string) \Fiber::suspend('error');
+                } catch (\Throwable $e) {
+                    $out .= $e->getMessage();
+                }
+                $out .= (string) \Fiber::suspend('baz');
+
+                // The scoped instance survived the injected throw and the suspensions around it.
+                return $out . '/' . $scoped->get(ContainerScopeService::class)->tag;
+            }),
+            static fn(string $value): string => $value === 'error'
+                ? throw new \RuntimeException('X')
+                : $value,
+        );
+
+        Assert::same($result, 'fooXbaz/7');
+    }
+
+    public function anUncaughtInjectedExceptionPropagatesOutOfTheScope(): never
+    {
+        $container = new ObjectContainer();
+
+        Expect::exception(\RuntimeException::class)->withMessage('boom');
+
+        Fibers::runInFiber(
+            static fn(): mixed => $container->scope(static function (ObjectContainer $scoped): string {
+                $scoped->get(ContainerScopeService::class);
+                \Fiber::suspend('foo');
+                return (string) \Fiber::suspend('error');
+            }),
+            static fn(string $value): string => $value === 'error'
+                ? throw new \RuntimeException('boom')
+                : $value,
+        );
+    }
+
+    public function manyConcurrentFibersKeepScopedStateIsolated(): void
+    {
+        $root = new ObjectContainer();
+
+        $scopeTagging = static fn(int $tag): callable => static function () use ($root, $tag): int {
+            return $root->scope(static function (ObjectContainer $scoped) use ($tag): int {
+                $scoped->get(ContainerScopeService::class)->tag = $tag;
+                \Fiber::suspend();
+                return $scoped->get(ContainerScopeService::class)->tag;
+            });
+        };
+
+        $results = Fibers::runSequence(
+            $scopeTagging(1),
+            $scopeTagging(2),
+            $scopeTagging(3),
+            $scopeTagging(4),
+            $scopeTagging(5),
+        );
+
+        Assert::same($results, [1, 2, 3, 4, 5]);
+    }
+}
diff --git a/internal/container/tests/Unit/ResolutionTest.php b/internal/container/tests/Unit/ResolutionTest.php
new file mode 100644
index 0000000..4b5d0c9
--- /dev/null
+++ b/internal/container/tests/Unit/ResolutionTest.php
@@ -0,0 +1,211 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit;
+
+use Internal\Container\Container;
+use Internal\Container\ObjectContainer;
+use Internal\Container\Tests\Unit\Stub\ConfigFactoriable;
+use Internal\Container\Tests\Unit\Stub\ContainerScopeService;
+use Internal\Container\Tests\Unit\Stub\DependentService;
+use Internal\Container\Tests\Unit\Stub\DestroyableService;
+use Internal\Container\Tests\Unit\Stub\Greeter;
+use Internal\Container\Tests\Unit\Stub\GreeterInterface;
+use Internal\Container\Tests\Unit\Stub\TagInflector;
+use Internal\Container\Tests\Unit\Stub\UnresolvableService;
+use Psr\Container\ContainerInterface;
+use Psr\Container\NotFoundExceptionInterface;
+use Testo\Assert;
+use Testo\Codecov\Covers;
+use Testo\Expect;
+use Testo\Test;
+
+/**
+ * Core {@see ObjectContainer} behaviour: resolution, caching, registration, bindings, inflectors and
+ * teardown — the synchronous surface every scope builds on.
+ */
+#[Test]
+#[Covers(ObjectContainer::class)]
+final class ResolutionTest
+{
+    public function getCachesTheSameInstance(): void
+    {
+        $container = new ObjectContainer();
+
+        Assert::same(
+            $container->get(ContainerScopeService::class),
+            $container->get(ContainerScopeService::class),
+        );
+    }
+
+    public function makeCreatesAFreshInstanceEachTime(): void
+    {
+        $container = new ObjectContainer();
+
+        $first = $container->make(ContainerScopeService::class);
+        $second = $container->make(ContainerScopeService::class);
+
+        Assert::notSame($first, $second);
+        Assert::notSame($container->get(ContainerScopeService::class), $first);
+    }
+
+    public function hasIsFalseUntilResolvedOrBound(): void
+    {
+        $container = new ObjectContainer();
+
+        Assert::false($container->has(GreeterInterface::class));
+
+        $container->bind(GreeterInterface::class, Greeter::class);
+        Assert::true($container->has(GreeterInterface::class));
+    }
+
+    public function hasIsTrueAfterResolution(): void
+    {
+        $container = new ObjectContainer();
+
+        Assert::false($container->has(ContainerScopeService::class));
+        $container->get(ContainerScopeService::class);
+        Assert::true($container->has(ContainerScopeService::class));
+    }
+
+    public function setStoresAServiceUnderItsClass(): void
+    {
+        $container = new ObjectContainer();
+        $service = new ContainerScopeService();
+        $service->tag = 5;
+
+        $container->set($service);
+
+        Assert::same($container->get(ContainerScopeService::class), $service);
+    }
+
+    public function setStoresAServiceUnderAnExplicitId(): void
+    {
+        $container = new ObjectContainer();
+        $greeter = new Greeter();
+
+        $container->set($greeter, GreeterInterface::class);
+
+        Assert::same($container->get(GreeterInterface::class), $greeter);
+    }
+
+    public function autowiresConstructorDependencies(): void
+    {
+        $container = new ObjectContainer();
+
+        $dependent = $container->get(DependentService::class);
+
+        Assert::instanceOf($dependent->dependency, ContainerScopeService::class);
+        Assert::same($dependent->dependency, $container->get(ContainerScopeService::class));
+    }
+
+    public function bindUsesAClosureAsFactory(): void
+    {
+        $container = new ObjectContainer();
+        $container->bind(ContainerScopeService::class, static function (): ContainerScopeService {
+            $service = new ContainerScopeService();
+            $service->tag = 55;
+            return $service;
+        });
+
+        Assert::same($container->get(ContainerScopeService::class)->tag, 55);
+    }
+
+    public function bindResolvesAClassAliasToItsImplementation(): void
+    {
+        $container = new ObjectContainer();
+        $container->bind(GreeterInterface::class, Greeter::class);
+
+        Assert::instanceOf($container->get(GreeterInterface::class), Greeter::class);
+    }
+
+    public function bindSuppliesConstructorArgumentsFromAnArray(): void
+    {
+        $container = new ObjectContainer();
+        $container->bind(UnresolvableService::class, ['count' => 5]);
+
+        Assert::same($container->get(UnresolvableService::class)->count, 5);
+    }
+
+    public function bindWithNullSelfBinds(): void
+    {
+        $container = new ObjectContainer();
+        $container->bind(ContainerScopeService::class);
+
+        Assert::true($container->has(ContainerScopeService::class));
+        Assert::instanceOf($container->get(ContainerScopeService::class), ContainerScopeService::class);
+    }
+
+    public function getPassesFirstTimeArgumentsToTheConstructor(): void
+    {
+        $container = new ObjectContainer();
+
+        Assert::same($container->get(UnresolvableService::class, ['count' => 9])->count, 9);
+    }
+
+    public function buildsFactoriableServicesThroughTheirCreateMethod(): void
+    {
+        $container = new ObjectContainer();
+        $container->bind(ConfigFactoriable::class);
+
+        $config = $container->get(ConfigFactoriable::class);
+
+        Assert::instanceOf($config, ConfigFactoriable::class);
+        Assert::instanceOf($config->service, ContainerScopeService::class);
+    }
+
+    public function runsInflectorsOverResolvedServices(): void
+    {
+        $container = new ObjectContainer();
+        $container->addInflector(new TagInflector());
+
+        Assert::same($container->make(ContainerScopeService::class)->tag, 100);
+    }
+
+    public function resolvesTheContainerInterfaceToItself(): void
+    {
+        $container = new ObjectContainer();
+
+        Assert::same($container->get(ContainerInterface::class), $container);
+        Assert::same($container->get(Container::class), $container);
+        Assert::same($container->get(ObjectContainer::class), $container);
+    }
+
+    public function destroyTearsDownManagedDestroyableServices(): void
+    {
+        $container = new ObjectContainer();
+        $service = $container->get(DestroyableService::class);
+
+        $container->destroy();
+
+        Assert::true($service->destroyed);
+    }
+
+    public function makeThrowsNotFoundForAnUnresolvableService(): never
+    {
+        $container = new ObjectContainer();
+
+        Expect::exception(NotFoundExceptionInterface::class);
+
+        $container->make(UnresolvableService::class);
+    }
+
+    public function bindRejectsANonExistentAliasClass(): never
+    {
+        $container = new ObjectContainer();
+
+        Expect::exception(\InvalidArgumentException::class);
+
+        $container->bind(GreeterInterface::class, 'No\\Such\\Class');
+    }
+
+    public function bindRejectsAnIncompatibleAlias(): never
+    {
+        $container = new ObjectContainer();
+
+        Expect::exception(\InvalidArgumentException::class);
+
+        $container->bind(GreeterInterface::class, ContainerScopeService::class);
+    }
+}
diff --git a/internal/container/tests/Unit/ScopeIsolationTest.php b/internal/container/tests/Unit/ScopeIsolationTest.php
new file mode 100644
index 0000000..4723f89
--- /dev/null
+++ b/internal/container/tests/Unit/ScopeIsolationTest.php
@@ -0,0 +1,193 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit;
+
+use Internal\Container\ObjectContainer;
+use Internal\Container\Tests\Unit\Stub\ContainerScopeService;
+use Internal\Container\Tests\Unit\Stub\Greeter;
+use Internal\Container\Tests\Unit\Stub\GreeterInterface;
+use Internal\Container\Tests\Unit\Stub\ReadonlyTag;
+use Testo\Assert;
+use Testo\Codecov\Covers;
+use Testo\Test;
+
+/**
+ * {@see ObjectContainer::scope()} isolation — synchronously and across interleaved fibers.
+ *
+ * A scope clones the active state, so its resolved services are its own; the active state is held per
+ * fiber (see {@see \Internal\Fiber\FiberLocal}), so two fibers each in their own scope never observe each
+ * other's instances even while interleaving on one thread.
+ */
+#[Test]
+#[Covers(ObjectContainer::class)]
+final class ScopeIsolationTest
+{
+    public function syncScopeIsolatesFromParent(): void
+    {
+        $container = new ObjectContainer();
+        $container->get(ContainerScopeService::class)->tag = 10;
+
+        $inside = $container->scope(static function (ObjectContainer $scoped): int {
+            $service = $scoped->get(ContainerScopeService::class);
+            $service->tag = 99;
+            return $service->tag;
+        });
+
+        Assert::same($inside, 99);
+        Assert::same($container->get(ContainerScopeService::class)->tag, 10);
+    }
+
+    public function nestedSyncScopesRestoreTheParent(): void
+    {
+        $container = new ObjectContainer();
+        $container->get(ContainerScopeService::class)->tag = 1;
+
+        $container->scope(static function (ObjectContainer $outer): void {
+            $outer->get(ContainerScopeService::class)->tag = 2;
+
+            $outer->scope(static function (ObjectContainer $inner): void {
+                $inner->get(ContainerScopeService::class)->tag = 3;
+            });
+
+            Assert::same($outer->get(ContainerScopeService::class)->tag, 2);
+        });
+
+        Assert::same($container->get(ContainerScopeService::class)->tag, 1);
+    }
+
+    public function scopeReturnsTheClosureResult(): void
+    {
+        $container = new ObjectContainer();
+
+        $result = $container->scope(static fn(): string => 'result');
+
+        Assert::same($result, 'result');
+    }
+
+    public function scopeInheritsAClonedCopyOfParentCachedServices(): void
+    {
+        $container = new ObjectContainer();
+        $parent = $container->get(ContainerScopeService::class);
+        $parent->tag = 7;
+
+        $container->scope(static function (ObjectContainer $scoped) use ($parent): void {
+            $inScope = $scoped->get(ContainerScopeService::class);
+            Assert::notSame($inScope, $parent);
+            Assert::same($inScope->tag, 7);
+            $inScope->tag = 99;
+        });
+
+        Assert::same($parent->tag, 7);
+    }
+
+    public function scopeSharesReadonlyServicesWithTheParent(): void
+    {
+        $container = new ObjectContainer();
+        $parent = $container->get(ReadonlyTag::class);
+
+        $inScope = $container->scope(static fn(ObjectContainer $scoped): ReadonlyTag => $scoped->get(ReadonlyTag::class));
+
+        Assert::same($inScope, $parent);
+    }
+
+    public function scopeInheritsParentBindings(): void
+    {
+        $container = new ObjectContainer();
+        $container->bind(GreeterInterface::class, Greeter::class);
+
+        $inScope = $container->scope(
+            static fn(ObjectContainer $scoped): GreeterInterface => $scoped->get(GreeterInterface::class),
+        );
+
+        Assert::instanceOf($inScope, Greeter::class);
+    }
+
+    public function bindingInsideAScopeDoesNotLeakToTheParent(): void
+    {
+        $container = new ObjectContainer();
+
+        $container->scope(static function (ObjectContainer $scoped): void {
+            $scoped->bind(GreeterInterface::class, Greeter::class);
+            Assert::true($scoped->has(GreeterInterface::class));
+        });
+
+        Assert::false($container->has(GreeterInterface::class));
+    }
+
+    public function scopeRestoresTheParentAfterAnException(): void
+    {
+        $container = new ObjectContainer();
+        $container->get(ContainerScopeService::class)->tag = 5;
+
+        try {
+            $container->scope(static function (ObjectContainer $scoped): never {
+                $scoped->get(ContainerScopeService::class)->tag = 42;
+                throw new \RuntimeException('boom');
+            });
+        } catch (\RuntimeException) {
+            // The throw is incidental — what we verify is that the parent scope is intact afterwards.
+        }
+
+        Assert::same($container->get(ContainerScopeService::class)->tag, 5);
+    }
+
+    public function deeplyNestedScopesEachRestoreTheirParent(): void
+    {
+        $container = new ObjectContainer();
+        $container->get(ContainerScopeService::class)->tag = 0;
+
+        $deepest = $container->scope(static function (ObjectContainer $l1): int {
+            $l1->get(ContainerScopeService::class)->tag = 1;
+
+            $inner = $l1->scope(static function (ObjectContainer $l2): int {
+                $l2->get(ContainerScopeService::class)->tag = 2;
+
+                $l3 = $l2->scope(static fn(ObjectContainer $c): int => $c->get(ContainerScopeService::class)->tag = 3);
+
+                Assert::same($l2->get(ContainerScopeService::class)->tag, 2);
+                return $l3;
+            });
+
+            Assert::same($l1->get(ContainerScopeService::class)->tag, 1);
+            return $inner;
+        });
+
+        Assert::same($deepest, 3);
+        Assert::same($container->get(ContainerScopeService::class)->tag, 0);
+    }
+
+    /**
+     * Two fibers each enter their own scope, park, then resume: each must still resolve its own scoped
+     * instance across the switch — the isolation invariant a real event loop relies on.
+     */
+    public function interleavedScopesKeepSeparateInstances(): void
+    {
+        $container = new ObjectContainer();
+        $seen = [];
+
+        $fiberA = new \Fiber(static function () use ($container, &$seen): void {
+            $container->scope(static function (ObjectContainer $scoped) use (&$seen): void {
+                $scoped->get(ContainerScopeService::class)->tag = 1;
+                \Fiber::suspend();
+                $seen['A'] = $scoped->get(ContainerScopeService::class)->tag;
+            });
+        });
+        $fiberB = new \Fiber(static function () use ($container, &$seen): void {
+            $container->scope(static function (ObjectContainer $scoped) use (&$seen): void {
+                $scoped->get(ContainerScopeService::class)->tag = 2;
+                \Fiber::suspend();
+                $seen['B'] = $scoped->get(ContainerScopeService::class)->tag;
+            });
+        });
+
+        $fiberA->start();
+        $fiberB->start();
+        $fiberA->resume();
+        $fiberB->resume();
+
+        Assert::same($seen['A'], 1);
+        Assert::same($seen['B'], 2);
+    }
+}
diff --git a/internal/container/tests/Unit/ScopeUnderFiberTest.php b/internal/container/tests/Unit/ScopeUnderFiberTest.php
new file mode 100644
index 0000000..85c63c9
--- /dev/null
+++ b/internal/container/tests/Unit/ScopeUnderFiberTest.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit;
+
+use Internal\Container\ObjectContainer;
+use Internal\Container\Tests\Unit\Stub\ContainerScopeService;
+use Testo\Assert;
+use Testo\Codecov\Covers;
+use Testo\Fiber\RunInFiber;
+use Testo\Fiber\Schedule;
+use Testo\Lifecycle\BeforeClass;
+use Testo\Test;
+
+/**
+ * Container `scope()` isolation through the real pipeline on Testo's cooperative fiber scheduler.
+ *
+ * Three tests share one {@see ObjectContainer} and run under `#[RunInFiber(Schedule::RoundRobin)]`, so they
+ * interleave at each `\Fiber::suspend()`. Each enters its own scope on the shared container, sets a distinct
+ * tag, then yields **repeatedly** — re-reading its scoped instance after every suspension. The tag must hold
+ * across all of them, proving the container's per-fiber state survives many rounds of two other tests
+ * running in between.
+ */
+#[Test]
+#[RunInFiber(Schedule::RoundRobin)]
+#[Covers(ObjectContainer::class)]
+final class ScopeUnderFiberTest
+{
+    private static ObjectContainer $container;
+
+    #[BeforeClass]
+    public static function bootContainer(): void
+    {
+        self::$container = new ObjectContainer();
+    }
+
+    public function firstScopeSurvivesTheInterleave(): void
+    {
+        self::scopeHoldsTagAcrossSuspends(1);
+    }
+
+    public function secondScopeSurvivesTheInterleave(): void
+    {
+        self::scopeHoldsTagAcrossSuspends(2);
+    }
+
+    public function thirdScopeSurvivesTheInterleave(): void
+    {
+        self::scopeHoldsTagAcrossSuspends(3);
+    }
+
+    /**
+     * Enter a scope, tag its {@see ContainerScopeService}, then suspend three times, asserting after each
+     * yield that the scoped instance still carries this test's own tag.
+     */
+    private static function scopeHoldsTagAcrossSuspends(int $tag): void
+    {
+        self::$container->scope(static function (ObjectContainer $scoped) use ($tag): void {
+            $scoped->get(ContainerScopeService::class)->tag = $tag;
+
+            for ($i = 0; $i < 3; $i++) {
+                \Fiber::suspend();
+                Assert::same($scoped->get(ContainerScopeService::class)->tag, $tag);
+            }
+        });
+    }
+}
diff --git a/internal/container/tests/Unit/ScopesRevoltTest.php b/internal/container/tests/Unit/ScopesRevoltTest.php
new file mode 100644
index 0000000..a1dab15
--- /dev/null
+++ b/internal/container/tests/Unit/ScopesRevoltTest.php
@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit;
+
+use Internal\Container\ObjectContainer;
+use Internal\Container\Tests\Testo\Loop;
+use Internal\Container\Tests\Unit\Stub\ContainerScopeService;
+use Revolt\EventLoop;
+use Testo\Assert;
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Codecov\Covers;
+use Testo\Test;
+
+/**
+ * Harness sanity for probing {@see ObjectContainer} under a real Revolt event loop.
+ *
+ * These first cases only prove the {@see Loop} harness itself — that a body runs inside a
+ * driver-managed fiber, that a suspension round-trips, and that the container resolves inside
+ * the loop. The scope-across-suspension behaviour (which today breaks via the fiber
+ * trampoline) is added on top of this harness next.
+ */
+#[Test]
+#[Covers(ObjectContainer::class)]
+final class ScopesRevoltTest
+{
+    public function loopRunsBodyInsideAFiberAndReturnsItsValue(): void
+    {
+        $insideFiber = false;
+        $value = Loop::run(static function () use (&$insideFiber): string {
+            $insideFiber = \Fiber::getCurrent() !== null;
+            return 'done';
+        });
+
+        Assert::true($insideFiber);
+        Assert::same($value, 'done');
+    }
+
+    public function tickRoundTripsThroughTheDriver(): void
+    {
+        $log = Loop::run(static function (): array {
+            $log = ['before'];
+            Loop::tick();
+            $log[] = 'after';
+            return $log;
+        });
+
+        Assert::same($log, ['before', 'after']);
+    }
+
+    public function throwableFromBodyPropagatesOutOfTheLoop(): void
+    {
+        $caught = null;
+        try {
+            Loop::run(static fn() => throw new \RuntimeException('boom'));
+        } catch (\RuntimeException $e) {
+            $caught = $e;
+        }
+
+        Assert::notNull($caught);
+        Assert::same($caught?->getMessage(), 'boom');
+    }
+
+    public function containerResolvesInsideTheLoop(): void
+    {
+        $service = Loop::run(static function (): object {
+            $container = new ObjectContainer();
+            return $container->get(ContainerScopeService::class);
+        });
+
+        Assert::instanceOf($service, ContainerScopeService::class);
+    }
+
+    /**
+     * A real Revolt await **inside** a container `scope()`: the scope's state must survive the
+     * suspension. The loop resumes this exact fiber directly, and because the active {@see State} is held
+     * per fiber (see {@see \Internal\Fiber\FiberLocal}), `get()` after the await still reads the scope's
+     * own instance (`tag = 42`), not a fresh parent one. Before the fiber-local migration this leaked via
+     * the fiber trampoline (returned `tag = 0`) or deadlocked the Revolt driver.
+     */
+    #[RunInRevolt]
+    public function scopeAcrossARevoltAwaitKeepsItsState(): void
+    {
+        $container = new ObjectContainer();
+
+        $container->scope(static function (ObjectContainer $scoped): void {
+            $scoped->get(ContainerScopeService::class)->tag = 42;
+
+            $suspension = EventLoop::getSuspension();
+            EventLoop::delay(0.001, static fn() => $suspension->resume());
+            $suspension->suspend();
+
+            Assert::same($scoped->get(ContainerScopeService::class)->tag, 42);
+        });
+    }
+}
diff --git a/internal/container/tests/Unit/Stub/ConfigFactoriable.php b/internal/container/tests/Unit/Stub/ConfigFactoriable.php
new file mode 100644
index 0000000..70bce7f
--- /dev/null
+++ b/internal/container/tests/Unit/Stub/ConfigFactoriable.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit\Stub;
+
+use Internal\Container\Factoriable;
+
+/**
+ * {@see Factoriable} stub — a private constructor plus an autowired static `create()`, so it can only be
+ * built through the factory path a binding selects for Factoriable classes.
+ *
+ * @internal
+ */
+final class ConfigFactoriable implements Factoriable
+{
+    private function __construct(
+        public ContainerScopeService $service,
+    ) {}
+
+    public static function create(ContainerScopeService $service): self
+    {
+        return new self($service);
+    }
+}
diff --git a/internal/container/tests/Unit/Stub/ContainerScopeService.php b/internal/container/tests/Unit/Stub/ContainerScopeService.php
new file mode 100644
index 0000000..18af86e
--- /dev/null
+++ b/internal/container/tests/Unit/Stub/ContainerScopeService.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit\Stub;
+
+/**
+ * Trivial autowirable service used to observe which container/scope resolves it.
+ *
+ * @internal
+ */
+final class ContainerScopeService
+{
+    /** @var int Distinguishes instances produced by different scopes/containers. */
+    public int $tag = 0;
+}
diff --git a/internal/container/tests/Unit/Stub/DependentService.php b/internal/container/tests/Unit/Stub/DependentService.php
new file mode 100644
index 0000000..e7adc35
--- /dev/null
+++ b/internal/container/tests/Unit/Stub/DependentService.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit\Stub;
+
+/**
+ * Autowirable service with a single object dependency, used to observe constructor injection.
+ *
+ * @internal
+ */
+final class DependentService
+{
+    public function __construct(
+        public ContainerScopeService $dependency,
+    ) {}
+}
diff --git a/internal/container/tests/Unit/Stub/DestroyableService.php b/internal/container/tests/Unit/Stub/DestroyableService.php
new file mode 100644
index 0000000..787b9d9
--- /dev/null
+++ b/internal/container/tests/Unit/Stub/DestroyableService.php
@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit\Stub;
+
+use Internal\Destroy\Destroyable;
+
+/**
+ * Records whether the container tore it down, so tests can observe {@see ObjectContainer::destroy()}.
+ *
+ * @internal
+ */
+final class DestroyableService implements Destroyable
+{
+    public bool $destroyed = false;
+
+    #[\Override]
+    public function destroy(): void
+    {
+        $this->destroyed = true;
+    }
+}
diff --git a/internal/container/tests/Unit/Stub/Greeter.php b/internal/container/tests/Unit/Stub/Greeter.php
new file mode 100644
index 0000000..4c80a57
--- /dev/null
+++ b/internal/container/tests/Unit/Stub/Greeter.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit\Stub;
+
+/**
+ * @internal
+ */
+final class Greeter implements GreeterInterface
+{
+    public function greet(): string
+    {
+        return 'hi';
+    }
+}
diff --git a/internal/container/tests/Unit/Stub/GreeterInterface.php b/internal/container/tests/Unit/Stub/GreeterInterface.php
new file mode 100644
index 0000000..d3c0604
--- /dev/null
+++ b/internal/container/tests/Unit/Stub/GreeterInterface.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit\Stub;
+
+/**
+ * @internal
+ */
+interface GreeterInterface
+{
+    public function greet(): string;
+}
diff --git a/internal/container/tests/Unit/Stub/ReadonlyTag.php b/internal/container/tests/Unit/Stub/ReadonlyTag.php
new file mode 100644
index 0000000..09595bf
--- /dev/null
+++ b/internal/container/tests/Unit/Stub/ReadonlyTag.php
@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit\Stub;
+
+/**
+ * Readonly service — a container scope shares it with its parent instead of cloning it.
+ *
+ * @internal
+ */
+final readonly class ReadonlyTag
+{
+    public function __construct(
+        public int $value = 7,
+    ) {}
+}
diff --git a/internal/container/tests/Unit/Stub/TagInflector.php b/internal/container/tests/Unit/Stub/TagInflector.php
new file mode 100644
index 0000000..bcd95fd
--- /dev/null
+++ b/internal/container/tests/Unit/Stub/TagInflector.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit\Stub;
+
+use Internal\Container\Container;
+use Internal\Container\Inflector;
+
+/**
+ * Bumps the tag of every {@see ContainerScopeService} it inflects, so tests can observe that the
+ * container ran its inflectors over a resolved service.
+ *
+ * @internal
+ */
+final class TagInflector implements Inflector
+{
+    #[\Override]
+    public function inflect(object $object, Container $container): object
+    {
+        $object instanceof ContainerScopeService and $object->tag += 100;
+        return $object;
+    }
+}
diff --git a/internal/container/tests/Unit/Stub/UnresolvableService.php b/internal/container/tests/Unit/Stub/UnresolvableService.php
new file mode 100644
index 0000000..bc2bd50
--- /dev/null
+++ b/internal/container/tests/Unit/Stub/UnresolvableService.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Container\Tests\Unit\Stub;
+
+/**
+ * Requires a scalar the autowirer cannot supply on its own, so `make()`/`get()` fail unless the value
+ * is provided via arguments or a binding.
+ *
+ * @internal
+ */
+final class UnresolvableService
+{
+    public function __construct(
+        public int $count,
+    ) {}
+}
diff --git a/internal/container/tests/suites.php b/internal/container/tests/suites.php
new file mode 100644
index 0000000..e447d24
--- /dev/null
+++ b/internal/container/tests/suites.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+use Testo\Application\Config\FinderConfig;
+use Testo\Application\Config\SuiteConfig;
+
+/**
+ * Test suites for the internal Container package.
+ */
+return [
+    new SuiteConfig(
+        name: 'Container/Unit',
+        location: new FinderConfig(
+            include: [__DIR__ . '/Unit'],
+        ),
+    ),
+];
diff --git a/internal/fiber/src/FiberLocal.php b/internal/fiber/src/FiberLocal.php
new file mode 100644
index 0000000..2d86a9d
--- /dev/null
+++ b/internal/fiber/src/FiberLocal.php
@@ -0,0 +1,113 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Fiber;
+
+/**
+ * A container whose value is scoped to the current fiber.
+ *
+ * Each fiber sees its own value; the main (no-fiber) thread has its own slot too. Reading from one fiber
+ * never observes what another fiber stored, so concurrently running fibers stay isolated with no manual
+ * save/restore at their switch points. A fiber's value is dropped once the fiber is garbage-collected.
+ *
+ * ```php
+ * $local = new FiberLocal('default');
+ *
+ * $local->get();               // 'default' — nothing bound in this context yet
+ *
+ * // scope() binds a value for the duration of a callback, then restores the previous one:
+ * $local->scope('scoped', function () use ($local): void {
+ *     $local->get();           // 'scoped'
+ * });
+ * $local->get();               // 'default' — restored
+ * ```
+ *
+ * @template T
+ */
+final class FiberLocal
+{
+    /** @var \WeakMap<\Fiber, T> */
+    private \WeakMap $byFiber;
+
+    /** @var T|null */
+    private mixed $main = null;
+
+    private bool $hasMain = false;
+
+    /**
+     * @param T $default Value seen before anything is set in the current context.
+     */
+    public function __construct(
+        private readonly mixed $default = null,
+    ) {
+        /** @psalm-suppress PropertyTypeCoercion an empty WeakMap is WeakMap<object, mixed> until keyed */
+        $this->byFiber = new \WeakMap();
+    }
+
+    /**
+     * @return T The value bound to the current fiber (or the main thread), or the default.
+     */
+    public function get(): mixed
+    {
+        $fiber = \Fiber::getCurrent();
+
+        return $fiber === null
+            ? ($this->hasMain ? $this->main : $this->default)
+            : ($this->byFiber[$fiber] ?? $this->default);
+    }
+
+    /**
+     * Bind $value to the current context, run $run, then restore the previous binding — even if $run
+     * throws. Re-entrant: nested scopes in the same fiber save and restore correctly.
+     *
+     * $destroy, if given, runs once after the binding is restored (a `finally` for the caller): it lets a
+     * scope tear its value down without an extra try/finally around the call.
+     *
+     * @template R
+     * @param T $value
+     * @param \Closure(): R $run
+     * @param \Closure(): void|null $destroy Cleanup for $value, run after the binding is restored.
+     * @return R
+     */
+    public function scope(mixed $value, \Closure $run, ?\Closure $destroy = null): mixed
+    {
+        $fiber = \Fiber::getCurrent();
+
+        try {
+            if ($fiber === null) {
+                $hadOld = $this->hasMain;
+                $old = $this->main;
+                $this->main = $value;
+                $this->hasMain = true;
+                try {
+                    return $run();
+                } finally {
+                    $this->hasMain = $hadOld;
+                    $this->main = $hadOld ? $old : null;
+                }
+            }
+
+            // Split on had/not-had so the restored value keeps its non-null type T.
+            if (isset($this->byFiber[$fiber])) {
+                $old = $this->byFiber[$fiber];
+                $this->byFiber[$fiber] = $value;
+                try {
+                    return $run();
+                } finally {
+                    /** @psalm-suppress PossiblyNullArgument $old came from an isset() slot, so it is a real T */
+                    $this->byFiber[$fiber] = $old;
+                }
+            }
+
+            $this->byFiber[$fiber] = $value;
+            try {
+                return $run();
+            } finally {
+                unset($this->byFiber[$fiber]);
+            }
+        } finally {
+            $destroy === null or $destroy();
+        }
+    }
+}
diff --git a/internal/fiber/tests/Unit/FiberLocalTest.php b/internal/fiber/tests/Unit/FiberLocalTest.php
new file mode 100644
index 0000000..ec1e47f
--- /dev/null
+++ b/internal/fiber/tests/Unit/FiberLocalTest.php
@@ -0,0 +1,151 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Internal\Fiber\Tests\Unit;
+
+use Internal\Fiber\FiberLocal;
+use Testo\Assert;
+use Testo\Codecov\Covers;
+use Testo\Test;
+
+#[Test]
+#[Covers(FiberLocal::class)]
+final class FiberLocalTest
+{
+    public function mainSlotDefaultsThenScopes(): void
+    {
+        $local = new FiberLocal('default');
+
+        Assert::same($local->get(), 'default');
+
+        $inside = $local->scope('scoped', static fn(): string => $local->get());
+        Assert::same($inside, 'scoped');
+        Assert::same($local->get(), 'default');
+    }
+
+    public function nestedScopeRestoresOuterValue(): void
+    {
+        $local = new FiberLocal('base');
+        $seen = [];
+
+        $local->scope('outer', static function () use ($local, &$seen): void {
+            $seen[] = $local->get();
+            $local->scope('inner', static function () use ($local, &$seen): void {
+                $seen[] = $local->get();
+            });
+            $seen[] = $local->get();
+        });
+
+        Assert::same($seen, ['outer', 'inner', 'outer']);
+        Assert::same($local->get(), 'base');
+    }
+
+    /**
+     * The interleaving invariant every guard relies on: while two fibers are driven turn by turn, each
+     * reads its own scoped value across every switch, with no swapping at the suspension boundary.
+     */
+    public function interleavedFibersEachReadOwnValue(): void
+    {
+        $local = new FiberLocal('base');
+        $log = [];
+
+        $fiberA = new \Fiber(static function () use ($local, &$log): void {
+            $local->scope('A', static function () use ($local, &$log): void {
+                $log[] = 'A:' . $local->get();
+                \Fiber::suspend();
+                $log[] = 'A:' . $local->get();
+            });
+        });
+        $fiberB = new \Fiber(static function () use ($local, &$log): void {
+            $local->scope('B', static function () use ($local, &$log): void {
+                $log[] = 'B:' . $local->get();
+                \Fiber::suspend();
+                $log[] = 'B:' . $local->get();
+            });
+        });
+
+        $fiberA->start();
+        $fiberB->start();
+        $fiberA->resume();
+        $fiberB->resume();
+
+        Assert::same($log, ['A:A', 'B:B', 'A:A', 'B:B']);
+        Assert::same($local->get(), 'base');
+    }
+
+    public function scopeRestoresAfterException(): void
+    {
+        $local = new FiberLocal('base');
+
+        try {
+            $local->scope('inner', static function (): never {
+                throw new \RuntimeException('boom');
+            });
+        } catch (\RuntimeException) {
+            // The throw is incidental machinery here — what we verify is the restore in scope()'s finally.
+        }
+
+        Assert::same($local->get(), 'base');
+    }
+
+    public function scopeRunsDestroyOnceAfterRestore(): void
+    {
+        $local = new FiberLocal('base');
+        $seenDuringDestroy = 'unset';
+        $calls = 0;
+
+        $local->scope(
+            'scoped',
+            static fn(): int => 1,
+            static function () use ($local, &$seenDuringDestroy, &$calls): void {
+                ++$calls;
+                $seenDuringDestroy = $local->get();
+            },
+        );
+
+        Assert::same($calls, 1);
+        Assert::same($seenDuringDestroy, 'base');
+    }
+
+    public function scopeRunsDestroyOnException(): void
+    {
+        $local = new FiberLocal('base');
+        $destroyed = false;
+
+        try {
+            $local->scope(
+                'scoped',
+                static function (): never {
+                    throw new \RuntimeException('boom');
+                },
+                static function () use (&$destroyed): void {
+                    $destroyed = true;
+                },
+            );
+        } catch (\RuntimeException) {
+        }
+
+        Assert::true($destroyed);
+    }
+
+    public function abandonedFiberSlotIsReleasedByGc(): void
+    {
+        $local = new FiberLocal('base');
+
+        // Park a fiber inside scope() so its restoring finally never runs — the slot lingers in the map.
+        $fiber = new \Fiber(static function () use ($local): void {
+            $local->scope('leaky', static fn() => \Fiber::suspend());
+        });
+        $fiber->start();
+
+        /** @var \WeakMap<\Fiber, mixed> $byFiber */
+        $byFiber = (new \ReflectionProperty(FiberLocal::class, 'byFiber'))->getValue($local);
+        Assert::count($byFiber, 1);
+
+        $fiber = null;
+        \gc_collect_cycles();
+
+        Assert::count($byFiber, 0);
+    }
+}
diff --git a/internal/fiber/tests/suites.php b/internal/fiber/tests/suites.php
new file mode 100644
index 0000000..8c4d60f
--- /dev/null
+++ b/internal/fiber/tests/suites.php
@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+use Testo\Application\Config\FinderConfig;
+use Testo\Application\Config\SuiteConfig;
+
+/**
+ * Test suites for the internal Fiber package.
+ */
+return [
+    new SuiteConfig(
+        name: 'Fiber/Internal/Unit',
+        location: new FinderConfig(
+            include: [__DIR__ . '/Unit'],
+        ),
+    ),
+];
diff --git a/plugin/assert/src/Internal/Assertion/AssertJson.php b/plugin/assert/src/Internal/Assertion/AssertJson.php
index 0ec90b4..e4512ab 100644
--- a/plugin/assert/src/Internal/Assertion/AssertJson.php
+++ b/plugin/assert/src/Internal/Assertion/AssertJson.php
@@ -116,7 +116,8 @@ public function assertPath(string $path, callable $callback): static
             "at path \"{$path}\"",
             '',
         );
-        StaticState::$state === null or StaticState::$state->history[] = $subParent;
+        $state = StaticState::current();
+        $state === null or $state->history[] = $subParent;
 
         $callback(new self($resolved, $subParent));
 
diff --git a/plugin/assert/src/Internal/Middleware/AssertCollectorInterceptor.php b/plugin/assert/src/Internal/Middleware/AssertCollectorInterceptor.php
index 6eea016..ba57219 100644
--- a/plugin/assert/src/Internal/Middleware/AssertCollectorInterceptor.php
+++ b/plugin/assert/src/Internal/Middleware/AssertCollectorInterceptor.php
@@ -38,45 +38,21 @@ public function __construct(
     public function runTest(TestInfo $info, callable $next): TestResult
     {
         $state = new TestState();
-        try {
-            $previous = StaticState::swap($state);
 
-            if (\Fiber::getCurrent() === null) {
-                # No Fiber, run the test directly
-                $result = $next($info);
-            } else {
-                # Create a Fiber scope to run the test
-                $fiber = new \Fiber(static fn(): TestResult => $next($info));
-
-                $value = $fiber->start();
-                while (!$fiber->isTerminated()) {
-                    StaticState::swap($previous);
-                    try {
-                        $resume = \Fiber::suspend($value);
-                    } catch (\Throwable $e) {
-                        $previous = StaticState::swap($state);
-                        $value = $fiber->throw($e);
-                        continue;
-                    }
-
-                    $previous = StaticState::swap($state);
-                    $value = $fiber->resume($resume);
-                }
-
-                /** @var TestResult $result */
-                $result = $fiber->getReturn();
-            }
-
-            $this->messenger->log(
-                AssertPlugin::CHANNEL_HISTORY,
-                HistoryRenderer::render($state->history),
-            );
-
-            return $result
-                ->withAttribute(TestState::class, $state)
-                ->withSummary($result->summary->withAddedMetric('assertions', \count($state->history)));
-        } finally {
-            StaticState::swap($previous);
-        }
+        // The collector is installed for the current fiber only, so concurrent tests keep separate
+        // histories. StaticState::scope() restores the previous collector on exit — including across a
+        // real event-loop suspension inside $next, where the loop resumes this exact fiber directly.
+        $result = StaticState::scope($state, static fn(): TestResult => $next($info));
+
+        // Emit after $next returns: the tree is only final here (composite records are appended empty and
+        // filled in afterwards, so streaming per assertion would serialize half-built structures).
+        $this->messenger->log(
+            AssertPlugin::CHANNEL_HISTORY,
+            HistoryRenderer::render($state->history),
+        );
+
+        return $result
+            ->withAttribute(TestState::class, $state)
+            ->withSummary($result->summary->withAddedMetric('assertions', \count($state->history)));
     }
 }
diff --git a/plugin/assert/src/Internal/StaticState.php b/plugin/assert/src/Internal/StaticState.php
index a9bbeea..b71e1f3 100644
--- a/plugin/assert/src/Internal/StaticState.php
+++ b/plugin/assert/src/Internal/StaticState.php
@@ -4,6 +4,7 @@
 
 namespace Testo\Assert\Internal;
 
+use Internal\Fiber\FiberLocal;
 use Testo\Assert\Exception\StateNotFound;
 use Testo\Assert\Internal\Expectation\ExpectedFail;
 use Testo\Assert\Internal\Expectation\ExpectExceptionHandler;
@@ -19,22 +20,29 @@
 /**
  * Holds the current assertion collector.
  *
+ * The active collector lives in a {@see FiberLocal} so each test fiber sees its own {@see TestState}:
+ * while tests interleave on one event loop, {@see Assert}'s reads and writes stay isolated per fiber
+ * without swapping a process-global slot at every suspension boundary.
+ *
  * @internal
  * @psalm-internal Testo\Assert
  */
 final class StaticState
 {
-    public static ?TestState $state = null;
+    /** @var FiberLocal<?TestState>|null */
+    private static ?FiberLocal $active = null;
 
     /**
-     * Swap the current collector with the given one.
+     * Install $state as the current collector for the current fiber, run $run, then restore the previous
+     * collector. Replaces the former swap()/child-fiber trampoline.
      *
-     * @return TestState|null The previous collector.
+     * @template R
+     * @param \Closure(): R $run
+     * @return R
      */
-    public static function swap(?TestState $collector): ?TestState
+    public static function scope(?TestState $state, \Closure $run): mixed
     {
-        [self::$state, $collector] = [$collector, self::$state];
-        return $collector;
+        return self::store()->scope($state, $run);
     }
 
     /**
@@ -42,7 +50,7 @@ public static function swap(?TestState $collector): ?TestState
      */
     public static function current(): ?TestState
     {
-        return self::$state;
+        return self::store()->get();
     }
 
     /**
@@ -53,7 +61,8 @@ public static function current(): ?TestState
     public static function typeSuccess(string $type, mixed $actual, string $message = ''): AssertionComposite
     {
         $result = new AssertionComposite(Support::stringify($actual), "is $type", $message);
-        self::$state === null or self::$state->history[] = $result;
+        $state = self::current();
+        $state === null or $state->history[] = $result;
         return $result;
     }
 
@@ -71,7 +80,8 @@ public static function typeFail(string $type, mixed $actual, string $message = '
             reason: "got " . Support::stringify($actual),
             details: '',
         );
-        self::$state === null or self::$state->history[] = $result;
+        $state = self::current();
+        $state === null or $state->history[] = $result;
         throw $result;
     }
 
@@ -82,7 +92,8 @@ public static function typeFail(string $type, mixed $actual, string $message = '
      */
     public static function success(mixed $value, string $assertion, string $context = ''): void
     {
-        self::$state === null or self::$state->history[] = new AssertionSuccess(
+        $state = self::current();
+        $state === null or $state->history[] = new AssertionSuccess(
             value: Support::stringify($value),
             assertion: $assertion,
             context: $context,
@@ -98,7 +109,8 @@ public static function success(mixed $value, string $assertion, string $context
      */
     public static function fail(Record&\Throwable $failure): never
     {
-        self::$state === null or self::$state->history[] = $failure;
+        $state = self::current();
+        $state === null or $state->history[] = $failure;
         throw $failure;
     }
 
@@ -118,17 +130,17 @@ public static function expectException(
         string|\Throwable $classOrObject,
         bool $same = false,
     ): ExpectExceptionHandler {
-        self::$state === null and throw new StateNotFound();
+        $state = self::current() ?? throw new StateNotFound();
 
-        return self::$state->expectations[] = $same
+        return $state->expectations[] = $same
             ? ExpectExceptionHandler::createSame($classOrObject)
             : ExpectExceptionHandler::createEquals($classOrObject);
     }
 
     public static function expectFail(Fail $exception): void
     {
-        self::$state === null and throw new StateNotFound();
-        self::$state->expectations[] = new ExpectedFail($exception);
+        $state = self::current() ?? throw new StateNotFound();
+        $state->expectations[] = new ExpectedFail($exception);
     }
 
     /**
@@ -140,9 +152,17 @@ public static function expectFail(Fail $exception): void
      */
     public static function trackObjectsLeak(bool $notLeaks, object ...$objects): Leaks|NotLeaks
     {
-        self::$state === null and throw new StateNotFound();
-        return self::$state->expectations[] = $notLeaks
+        $state = self::current() ?? throw new StateNotFound();
+        return $state->expectations[] = $notLeaks
             ? new NotLeaks(...$objects)
             : new Leaks(...$objects);
     }
+
+    /**
+     * @return FiberLocal<?TestState>
+     */
+    private static function store(): FiberLocal
+    {
+        return self::$active ??= new FiberLocal(null);
+    }
 }
diff --git a/plugin/assert/tests/Feature/ConcurrentAssertIsolationTest.php b/plugin/assert/tests/Feature/ConcurrentAssertIsolationTest.php
new file mode 100644
index 0000000..5710e5e
--- /dev/null
+++ b/plugin/assert/tests/Feature/ConcurrentAssertIsolationTest.php
@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Assert\Feature;
+
+use Testo\Assert;
+use Testo\Assert\Internal\Middleware\AssertCollectorInterceptor;
+use Testo\Assert\Internal\StaticState;
+use Testo\Assert\TestState;
+use Testo\Codecov\Covers;
+use Testo\Core\Context\TestResult;
+use Testo\Core\Value\Status;
+use Testo\Test;
+use Testo\Testing\Attribute\TestingSuite;
+use Testo\Testing\Helper\TestRunner;
+use Tests\Assert\Stub\Concurrency\RandomAssertScenarios;
+use Tests\Assert\Stub\Concurrency\RevoltAssertScenarios;
+use Tests\Assert\Stub\Concurrency\RoundRobinAssertScenarios;
+
+/**
+ * The Assert collector is a fiber-local guard ({@see StaticState}), so concurrently running tests each
+ * get their own {@see TestState}. These cases drive stub suites whose tests interleave — on Testo's fiber
+ * scheduler and on a real Revolt loop — each recording a distinct number of assertions across many
+ * suspensions. After the run, each test's own history must hold exactly its own assertions: concurrency
+ * must not let one test's assertions bleed into another's history.
+ */
+#[Test]
+#[Covers(StaticState::class)]
+#[Covers(AssertCollectorInterceptor::class)]
+#[TestingSuite(path: __DIR__ . '/../Stub/Concurrency')]
+final class ConcurrentAssertIsolationTest
+{
+    public function fiberRoundRobinTestsKeepSeparateHistories(): void
+    {
+        self::assertHistoryCount(
+            TestRunner::runTest([RoundRobinAssertScenarios::class, 'recordsThreeAssertions']),
+            3,
+        );
+        self::assertHistoryCount(
+            TestRunner::runTest([RoundRobinAssertScenarios::class, 'recordsFourAssertions']),
+            4,
+        );
+        self::assertHistoryCount(
+            TestRunner::runTest([RoundRobinAssertScenarios::class, 'recordsFiveAssertions']),
+            5,
+        );
+    }
+
+    public function fiberRandomScheduleKeepsSeparateHistories(): void
+    {
+        self::assertHistoryCount(
+            TestRunner::runTest([RandomAssertScenarios::class, 'recordsThreeAssertions']),
+            3,
+        );
+        self::assertHistoryCount(
+            TestRunner::runTest([RandomAssertScenarios::class, 'recordsFourAssertions']),
+            4,
+        );
+        self::assertHistoryCount(
+            TestRunner::runTest([RandomAssertScenarios::class, 'recordsFiveAssertions']),
+            5,
+        );
+    }
+
+    public function revoltPerCaseTestsKeepSeparateHistories(): void
+    {
+        self::assertHistoryCount(
+            TestRunner::runTest([RevoltAssertScenarios::class, 'recordsThreeAssertions']),
+            3,
+        );
+        self::assertHistoryCount(
+            TestRunner::runTest([RevoltAssertScenarios::class, 'recordsFourAssertions']),
+            4,
+        );
+        self::assertHistoryCount(
+            TestRunner::runTest([RevoltAssertScenarios::class, 'recordsFiveAssertions']),
+            5,
+        );
+    }
+
+    /**
+     * A test that recorded `$expected` passing assertions must pass and carry exactly that many records in
+     * its own {@see TestState} — no more (a sibling's leaked in) and no fewer (its own leaked out).
+     */
+    private static function assertHistoryCount(TestResult $result, int $expected): void
+    {
+        Assert::same($result->status, Status::Passed);
+
+        $state = $result->getAttribute(TestState::class);
+        Assert::instanceOf($state, TestState::class);
+        Assert::count($state->history, $expected);
+    }
+}
diff --git a/plugin/assert/tests/Stub/Concurrency/RandomAssertScenarios.php b/plugin/assert/tests/Stub/Concurrency/RandomAssertScenarios.php
new file mode 100644
index 0000000..b69b0fb
--- /dev/null
+++ b/plugin/assert/tests/Stub/Concurrency/RandomAssertScenarios.php
@@ -0,0 +1,47 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Assert\Stub\Concurrency;
+
+use Testo\Assert;
+use Testo\Fiber\RunInFiber;
+use Testo\Fiber\Schedule;
+use Testo\Test;
+
+/**
+ * Same distinct-count assertion isolation as {@see RoundRobinAssertScenarios}, but under
+ * {@see Schedule::Random}: the scheduler steps one random ready fiber each round, so the interleave order
+ * is non-deterministic. The per-test count each test ends up with must stay deterministic regardless —
+ * that is exactly what proves the fiber-local assert collector is not affected by the switching order.
+ */
+#[Test]
+#[RunInFiber(Schedule::Random)]
+final class RandomAssertScenarios
+{
+    public function recordsThreeAssertions(): void
+    {
+        self::assertAcrossSuspends(3);
+    }
+
+    public function recordsFourAssertions(): void
+    {
+        self::assertAcrossSuspends(4);
+    }
+
+    public function recordsFiveAssertions(): void
+    {
+        self::assertAcrossSuspends(5);
+    }
+
+    /**
+     * Record exactly `$count` passing assertions, suspending after each so the other tests interleave.
+     */
+    private static function assertAcrossSuspends(int $count): void
+    {
+        for ($i = 1; $i <= $count; $i++) {
+            Assert::same($i, $i);
+            \Fiber::suspend();
+        }
+    }
+}
diff --git a/plugin/assert/tests/Stub/Concurrency/RevoltAssertScenarios.php b/plugin/assert/tests/Stub/Concurrency/RevoltAssertScenarios.php
new file mode 100644
index 0000000..f145a8b
--- /dev/null
+++ b/plugin/assert/tests/Stub/Concurrency/RevoltAssertScenarios.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Assert\Stub\Concurrency;
+
+use Revolt\EventLoop;
+use Testo\Assert;
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Bridge\Revolt\Strategy;
+use Testo\Test;
+
+/**
+ * The same distinct-count assertion isolation as {@see RoundRobinAssertScenarios}, but on a **real Revolt
+ * loop** ({@see Strategy::PerCase}): all three tests are launched at once and interleave at genuine await
+ * points (a timer per assertion, far more than two suspensions each). Each test must still find exactly its
+ * own assertions in its {@see \Testo\Assert\TestState} — proving the fiber-local collector survives real
+ * event-loop scheduling, where the loop resumes each test's own fiber directly.
+ */
+#[Test]
+#[RunInRevolt(Strategy::PerCase)]
+final class RevoltAssertScenarios
+{
+    public function recordsThreeAssertions(): void
+    {
+        self::assertAcrossAwaits(3);
+    }
+
+    public function recordsFourAssertions(): void
+    {
+        self::assertAcrossAwaits(4);
+    }
+
+    public function recordsFiveAssertions(): void
+    {
+        self::assertAcrossAwaits(5);
+    }
+
+    /**
+     * Record exactly `$count` passing assertions, awaiting a real timer after each so the other tests
+     * genuinely interleave on the loop.
+     */
+    private static function assertAcrossAwaits(int $count): void
+    {
+        for ($i = 1; $i <= $count; $i++) {
+            Assert::same($i, $i);
+
+            $suspension = EventLoop::getSuspension();
+            EventLoop::delay(0.001, static fn() => $suspension->resume());
+            $suspension->suspend();
+        }
+    }
+}
diff --git a/plugin/assert/tests/Stub/Concurrency/RoundRobinAssertScenarios.php b/plugin/assert/tests/Stub/Concurrency/RoundRobinAssertScenarios.php
new file mode 100644
index 0000000..84d1588
--- /dev/null
+++ b/plugin/assert/tests/Stub/Concurrency/RoundRobinAssertScenarios.php
@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Assert\Stub\Concurrency;
+
+use Testo\Assert;
+use Testo\Fiber\RunInFiber;
+use Testo\Fiber\Schedule;
+use Testo\Test;
+
+/**
+ * Three tests interleaved on Testo's cooperative fiber scheduler ({@see Schedule::RoundRobin}), each
+ * recording a **distinct number** of passing assertions and yielding with `\Fiber::suspend()` after every
+ * one — so a sibling runs between each of this test's assertions. The assert collector is fiber-local
+ * ({@see \Testo\Assert\Internal\StaticState}); if it leaked across fibers, a test's own history would end
+ * up with the wrong count. Driven through {@see \Testo\Testing\Helper\TestRunner} by the Feature suite,
+ * which reads each test's {@see \Testo\Assert\TestState} back off the result and checks the exact count.
+ */
+#[Test]
+#[RunInFiber(Schedule::RoundRobin)]
+final class RoundRobinAssertScenarios
+{
+    public function recordsThreeAssertions(): void
+    {
+        self::assertAcrossSuspends(3);
+    }
+
+    public function recordsFourAssertions(): void
+    {
+        self::assertAcrossSuspends(4);
+    }
+
+    public function recordsFiveAssertions(): void
+    {
+        self::assertAcrossSuspends(5);
+    }
+
+    /**
+     * Record exactly `$count` passing assertions, suspending after each so the other tests interleave.
+     */
+    private static function assertAcrossSuspends(int $count): void
+    {
+        for ($i = 1; $i <= $count; $i++) {
+            Assert::same($i, $i);
+            \Fiber::suspend();
+        }
+    }
+}
diff --git a/plugin/fiber/src/Internal/RunInFiberInterceptor.php b/plugin/fiber/src/Internal/RunInFiberInterceptor.php
index 54e4390..bc096fa 100644
--- a/plugin/fiber/src/Internal/RunInFiberInterceptor.php
+++ b/plugin/fiber/src/Internal/RunInFiberInterceptor.php
@@ -25,13 +25,17 @@
  * - {@see runTest()} (method-level) wraps a single test in its own fiber. When the case is already
  *   scheduling (a class-level `#[RunInFiber]`), it is a pass-through to avoid double-wrapping.
  *
- * Sits at {@see InterceptorOptions::ORDER_CLOSE_TO_TEST} — the innermost interceptor, so lifecycle/DI
- * still wrap the whole case while only the test loop / test body moves onto a fiber.
+ * Sits **outer** to the fiber-aware scoped-state guards (order just outside {@see
+ * InterceptorOptions::ORDER_DATA_PROVIDER}): the method-level fiber wraps the whole per-test pipeline —
+ * assertion collector, messenger scope, the test body — so the guards run *inside* the fiber. They hold
+ * their state per fiber (see {@see \Internal\Fiber\FiberLocal}), so each test reads its own scoped state
+ * even while several interleave; a data-driven/retried test runs all its datasets/attempts in its single
+ * fiber (data provider stays inner to the wrap).
  *
  * @internal
  * @psalm-internal Testo\Fiber
  */
-#[InterceptorOptions(order: InterceptorOptions::ORDER_CLOSE_TO_TEST, onConflict: ConflictPolicy::Last)]
+#[InterceptorOptions(order: InterceptorOptions::ORDER_DATA_PROVIDER - 1, onConflict: ConflictPolicy::Last)]
 final readonly class RunInFiberInterceptor implements TestCaseRunInterceptor, TestRunInterceptor
 {
     public function __construct(
diff --git a/resources/version.json b/resources/version.json
index 341df75..787a2fe 100644
--- a/resources/version.json
+++ b/resources/version.json
@@ -16,5 +16,6 @@
     "bridge/symfony-console": "0.1.8",
     "bridge/infection": "0.1.8",
     "bridge/mockery": "0.1.1",
-    "bridge/rector": "0.2.0"
+    "bridge/rector": "0.2.0",
+    "bridge/revolt": "0.1.0"
 }
diff --git a/testo.php b/testo.php
index 82374d6..68a58c7 100644
--- a/testo.php
+++ b/testo.php
@@ -11,8 +11,10 @@
     src: new FinderConfig(
         ['core', 'plugin', 'bridge'],
         [
+            'internal/container/tests',
             'bridge/mockery/tests',
             'bridge/rector/tests',
+            'bridge/revolt/tests',
             'bridge/symfony-console/tests',
             'plugin/assert/tests',
             'plugin/fiber/tests',
@@ -47,8 +49,11 @@
                 ),
             ),
         ],
+        require 'internal/container/tests/suites.php',
+        require 'internal/fiber/tests/suites.php',
         require 'bridge/mockery/tests/suites.php',
         require 'bridge/rector/tests/suites.php',
+        require 'bridge/revolt/tests/suites.php',
         require 'bridge/symfony-console/tests/suites.php',
         require 'plugin/assert/tests/suites.php',
         require 'plugin/fiber/tests/suites.php',
diff --git a/tests/Application/Feature/Messenger/ConcurrentMessengerIsolationTest.php b/tests/Application/Feature/Messenger/ConcurrentMessengerIsolationTest.php
new file mode 100644
index 0000000..2341fa7
--- /dev/null
+++ b/tests/Application/Feature/Messenger/ConcurrentMessengerIsolationTest.php
@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Application\Feature\Messenger;
+
+use Testo\Application\Internal\MessengerHub;
+use Testo\Assert;
+use Testo\Codecov\Covers;
+use Testo\Core\Context\TestResult;
+use Testo\Core\Log\Message;
+use Testo\Core\Value\Status;
+use Testo\Test;
+use Testo\Testing\Attribute\TestingSuite;
+use Testo\Testing\Helper\TestRunner;
+use Testo\Testing\InjectPlugin;
+use Tests\Application\Stub\Messenger\Concurrency\MessengerConcurrency;
+use Tests\Application\Stub\Messenger\Concurrency\RevoltMessengerScenarios;
+use Tests\Application\Stub\Messenger\Concurrency\RoundRobinMessengerScenarios;
+
+/**
+ * The messenger keeps each test's message buffer in a fiber-local guard ({@see MessengerHub}). These cases
+ * drive stub suites whose tests interleave — on Testo's fiber scheduler and on a real Revolt loop — each
+ * logging a distinct set of messages across many suspensions. Every test's captured messages, read back off
+ * its {@see TestResult}, must be exactly its own: concurrency must not let one test's output leak into
+ * another's buffer.
+ */
+#[Test]
+#[Covers(MessengerHub::class)]
+#[TestingSuite(
+    path: __DIR__ . '/../../Stub/Messenger/Concurrency',
+    plugins: [InjectPlugin::class],
+)]
+final class ConcurrentMessengerIsolationTest
+{
+    public function fiberRoundRobinTestsKeepSeparateMessageBuffers(): void
+    {
+        self::assertOwnMessages(
+            TestRunner::runTest([RoundRobinMessengerScenarios::class, 'alphaLogsThreeMessages']),
+            'alpha',
+            3,
+        );
+        self::assertOwnMessages(
+            TestRunner::runTest([RoundRobinMessengerScenarios::class, 'betaLogsFourMessages']),
+            'beta',
+            4,
+        );
+        self::assertOwnMessages(
+            TestRunner::runTest([RoundRobinMessengerScenarios::class, 'gammaLogsFiveMessages']),
+            'gamma',
+            5,
+        );
+    }
+
+    public function revoltPerCaseTestsKeepSeparateMessageBuffers(): void
+    {
+        self::assertOwnMessages(
+            TestRunner::runTest([RevoltMessengerScenarios::class, 'alphaLogsThreeMessages']),
+            'alpha',
+            3,
+        );
+        self::assertOwnMessages(
+            TestRunner::runTest([RevoltMessengerScenarios::class, 'betaLogsFourMessages']),
+            'beta',
+            4,
+        );
+        self::assertOwnMessages(
+            TestRunner::runTest([RevoltMessengerScenarios::class, 'gammaLogsFiveMessages']),
+            'gamma',
+            5,
+        );
+    }
+
+    /**
+     * The test passed (its own in-fiber isolation check held) and the messages captured onto its result are
+     * exactly its own `$prefix`-tagged messages, in order — no sibling's message leaked into the buffer.
+     */
+    private static function assertOwnMessages(TestResult $result, string $prefix, int $count): void
+    {
+        Assert::same($result->status, Status::Passed);
+
+        $contents = \array_map(
+            static fn(Message $message): string => $message->content,
+            $result->messages->channel(MessengerConcurrency::CHANNEL),
+        );
+
+        $expected = [];
+        for ($i = 1; $i <= $count; $i++) {
+            $expected[] = $prefix . '-' . $i;
+        }
+
+        Assert::same($contents, $expected);
+    }
+}
diff --git a/tests/Application/Stub/Messenger/Concurrency/MessengerConcurrency.php b/tests/Application/Stub/Messenger/Concurrency/MessengerConcurrency.php
new file mode 100644
index 0000000..58490ef
--- /dev/null
+++ b/tests/Application/Stub/Messenger/Concurrency/MessengerConcurrency.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Application\Stub\Messenger\Concurrency;
+
+/**
+ * Shared channel name for the messenger concurrency stubs and their Feature suite. Not a test case
+ * (no {@see \Testo\Test} methods), just the constant both sides agree on.
+ */
+final class MessengerConcurrency
+{
+    /** @var non-empty-string */
+    public const CHANNEL = 'guard-messenger';
+}
diff --git a/tests/Application/Stub/Messenger/Concurrency/RevoltMessengerScenarios.php b/tests/Application/Stub/Messenger/Concurrency/RevoltMessengerScenarios.php
new file mode 100644
index 0000000..f4fbf73
--- /dev/null
+++ b/tests/Application/Stub/Messenger/Concurrency/RevoltMessengerScenarios.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Application\Stub\Messenger\Concurrency;
+
+use Revolt\EventLoop;
+use Testo\Assert;
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Bridge\Revolt\Strategy;
+use Testo\Common\Messenger;
+use Testo\Core\Log\Message;
+use Testo\Test;
+use Testo\Testing\Attribute\Inject;
+
+/**
+ * The same distinct-messages isolation as {@see RoundRobinMessengerScenarios}, but on a **real Revolt loop**
+ * ({@see Strategy::PerCase}): all three tests run at once and interleave at genuine await points (a timer
+ * after every logged message). Each test must still read back only its own messages from the shared
+ * fiber-local {@see Messenger}, proving the buffer stays per-test through real event-loop scheduling.
+ */
+#[Test]
+#[RunInRevolt(Strategy::PerCase)]
+final class RevoltMessengerScenarios
+{
+    #[Inject]
+    private Messenger $messenger;
+
+    public function alphaLogsThreeMessages(): void
+    {
+        $this->logAndVerifyOwnMessages('alpha', 3);
+    }
+
+    public function betaLogsFourMessages(): void
+    {
+        $this->logAndVerifyOwnMessages('beta', 4);
+    }
+
+    public function gammaLogsFiveMessages(): void
+    {
+        $this->logAndVerifyOwnMessages('gamma', 5);
+    }
+
+    /**
+     * Log `$count` messages tagged with `$prefix`, awaiting a real timer after each so the other tests
+     * interleave on the loop, then assert this test's own buffer holds exactly its own messages.
+     */
+    private function logAndVerifyOwnMessages(string $prefix, int $count): void
+    {
+        $expected = [];
+        for ($i = 1; $i <= $count; $i++) {
+            $content = $prefix . '-' . $i;
+            $this->messenger->log(MessengerConcurrency::CHANNEL, $content);
+            $expected[] = $content;
+
+            $suspension = EventLoop::getSuspension();
+            EventLoop::delay(0.001, static fn() => $suspension->resume());
+            $suspension->suspend();
+        }
+
+        $mine = \array_map(
+            static fn(Message $message): string => $message->content,
+            $this->messenger->getMessages()->channel(MessengerConcurrency::CHANNEL),
+        );
+
+        Assert::same($mine, $expected);
+    }
+}
diff --git a/tests/Application/Stub/Messenger/Concurrency/RoundRobinMessengerScenarios.php b/tests/Application/Stub/Messenger/Concurrency/RoundRobinMessengerScenarios.php
new file mode 100644
index 0000000..46c6261
--- /dev/null
+++ b/tests/Application/Stub/Messenger/Concurrency/RoundRobinMessengerScenarios.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Application\Stub\Messenger\Concurrency;
+
+use Testo\Assert;
+use Testo\Common\Messenger;
+use Testo\Core\Log\Message;
+use Testo\Fiber\RunInFiber;
+use Testo\Fiber\Schedule;
+use Testo\Test;
+use Testo\Testing\Attribute\Inject;
+
+/**
+ * Three tests interleaved on Testo's fiber scheduler ({@see Schedule::RoundRobin}), each logging a distinct
+ * set of messages on the shared {@see Messenger} across several `\Fiber::suspend()`s. The messenger keeps
+ * its per-test buffer in a fiber-local guard ({@see \Testo\Application\Internal\MessengerHub}), so each test
+ * must read back only its own messages even though a sibling logged into the same {@see Messenger} in
+ * between. Every test verifies its own view here; the Feature suite additionally checks each test's
+ * captured messages off the {@see \Testo\Core\Context\TestResult}.
+ */
+#[Test]
+#[RunInFiber(Schedule::RoundRobin)]
+final class RoundRobinMessengerScenarios
+{
+    #[Inject]
+    private Messenger $messenger;
+
+    public function alphaLogsThreeMessages(): void
+    {
+        $this->logAndVerifyOwnMessages('alpha', 3);
+    }
+
+    public function betaLogsFourMessages(): void
+    {
+        $this->logAndVerifyOwnMessages('beta', 4);
+    }
+
+    public function gammaLogsFiveMessages(): void
+    {
+        $this->logAndVerifyOwnMessages('gamma', 5);
+    }
+
+    /**
+     * Log `$count` messages tagged with `$prefix` on the {@see MessengerConcurrency::CHANNEL} channel,
+     * suspending after each so the other tests interleave, then assert this test's own message buffer holds
+     * exactly its own messages — nothing a sibling logged in between.
+     */
+    private function logAndVerifyOwnMessages(string $prefix, int $count): void
+    {
+        $expected = [];
+        for ($i = 1; $i <= $count; $i++) {
+            $content = $prefix . '-' . $i;
+            $this->messenger->log(MessengerConcurrency::CHANNEL, $content);
+            $expected[] = $content;
+            \Fiber::suspend();
+        }
+
+        $mine = \array_map(
+            static fn(Message $message): string => $message->content,
+            $this->messenger->getMessages()->channel(MessengerConcurrency::CHANNEL),
+        );
+
+        Assert::same($mine, $expected);
+    }
+}
diff --git a/tests/Core/Pipeline/OutputInterceptorTest.php b/tests/Core/Pipeline/OutputInterceptorTest.php
index a395d2c..34274db 100644
--- a/tests/Core/Pipeline/OutputInterceptorTest.php
+++ b/tests/Core/Pipeline/OutputInterceptorTest.php
@@ -8,6 +8,7 @@
 use Testo\Codecov\Covers;
 use Testo\Common\Messenger;
 use Testo\Core\Context\CaseInfo;
+use Testo\Core\Context\TestIdentity;
 use Testo\Core\Context\TestInfo;
 use Testo\Core\Context\TestResult;
 use Testo\Core\Definition\CaseDefinition;
@@ -31,7 +32,7 @@ public function runTestCallsNextWithInfoAndReturnsResult(): void
         $testResult = new TestResult($testInfo, Status::Passed);
 
         $received = null;
-        $result = $interceptor->runTest($testInfo, function(TestInfo $info) use (&$received, $testResult): TestResult {
+        $result = $interceptor->runTest($testInfo, static function (TestInfo $info) use (&$received, $testResult): TestResult {
             $received = $info;
             return $testResult;
         });
@@ -47,7 +48,7 @@ public function runTestReturnsOriginalResultWhenMessagesEmpty(): void
         $interceptor = new OutputInterceptor($messenger);
         $testResult = new TestResult($testInfo, Status::Passed);
 
-        $result = $interceptor->runTest($testInfo, fn() => $testResult);
+        $result = $interceptor->runTest($testInfo, static fn() => $testResult);
 
         Assert::same($result, $testResult);
         Assert::true($result->messages->isEmpty());
@@ -60,7 +61,7 @@ public function runTestAttachesMessagesToResultWhenMessagesPresent(): void
         $interceptor = new OutputInterceptor($messenger);
         $testResult = new TestResult($testInfo, Status::Passed);
 
-        $result = $interceptor->runTest($testInfo, function() use ($messenger, $testResult): TestResult {
+        $result = $interceptor->runTest($testInfo, static function () use ($messenger, $testResult): TestResult {
             $messenger->recordMessage(new Message(
                 time: \microtime(true),
                 channel: 'stdout',
@@ -86,7 +87,7 @@ public function runTestIsolatesPreScopeMessagesFromResult(): void
         $interceptor = new OutputInterceptor($messenger);
         $testResult = new TestResult($testInfo, Status::Passed);
 
-        $result = $interceptor->runTest($testInfo, function() use ($messenger, $testResult): TestResult {
+        $result = $interceptor->runTest($testInfo, static function () use ($messenger, $testResult): TestResult {
             $messenger->recordMessage(new Message(
                 time: \microtime(true),
                 channel: 'stdout',
@@ -107,7 +108,7 @@ public function runTestPreservesResultStatusWhenAttachingMessages(): void
         $interceptor = new OutputInterceptor($messenger);
         $testResult = new TestResult($testInfo, Status::Failed, failure: new \Exception('Test failed'));
 
-        $result = $interceptor->runTest($testInfo, function() use ($messenger, $testResult): TestResult {
+        $result = $interceptor->runTest($testInfo, static function () use ($messenger, $testResult): TestResult {
             $messenger->recordMessage(new Message(
                 time: \microtime(true),
                 channel: 'stdout',
@@ -167,7 +168,7 @@ public function channel(string $name): Messenger\Channel
      * empty child buffer for the duration of the callback so {@see getMessages()} inside observes
      * only what was written within the scope, then restores the parent and discards the child.
      */
-    public function scope(\Closure $scope): mixed
+    public function scope(\Closure $scope, ?TestIdentity $identity = null): mixed
     {
         $parent = $this->messages;
         $this->messages = [];
diff --git a/tests/Output/Unit/Teamcity/TeamcityLoggerTest.php b/tests/Output/Unit/Teamcity/TeamcityLoggerTest.php
index 1b488f1..d0e2aa8 100644
--- a/tests/Output/Unit/Teamcity/TeamcityLoggerTest.php
+++ b/tests/Output/Unit/Teamcity/TeamcityLoggerTest.php
@@ -12,6 +12,8 @@
 use Testo\Core\Context\TestResult;
 use Testo\Core\Definition\CaseDefinition;
 use Testo\Core\Definition\TestDefinition;
+use Testo\Core\Log\Level;
+use Testo\Core\Log\Message;
 use Testo\Core\Value\Status;
 use Testo\Output\Teamcity\Teamcity\TeamcityLogger;
 use Testo\Test;
@@ -124,6 +126,53 @@ public function logEmptyRunEmitsBuildProblem(): void
         Assert::string($output)->contains("description='No tests were executed'");
     }
 
+    public function testStartedFromInfoStampsFlowIdFromIdentity(): void
+    {
+        $info = self::makeInfo('passingTest');
+
+        $output = self::capture(static fn(TeamcityLogger $logger) => $logger->testStartedFromInfo($info));
+
+        Assert::string($output)->contains("flowId='{$info->identity->id}'");
+    }
+
+    public function handleSingleTestResultStampsFlowIdFromIdentity(): void
+    {
+        $result = self::makeFailedResult(new \RuntimeException('boom'));
+
+        $output = self::capture(static fn(TeamcityLogger $logger) => $logger->handleSingleTestResult($result));
+
+        // Both the failure and the finish message carry the test's flow, so a consumer keeps them together.
+        Assert::same(\substr_count($output, "flowId='{$result->info->identity->id}'"), 2);
+    }
+
+    public function logMessageStampsTheGivenFlowId(): void
+    {
+        $message = new Message(time: 0.0, channel: 'stdout', level: Level::Info, content: 'streamed line');
+
+        $output = self::capture(
+            static fn(TeamcityLogger $logger) => $logger->logMessage('someTest', $message, '4242'),
+        );
+
+        Assert::string($output)->contains("flowId='4242'");
+        Assert::string($output)->contains('streamed line');
+    }
+
+    public function distinctTestsGetDistinctFlowIds(): void
+    {
+        $first = self::makeInfo('passingTest');
+        $second = self::makeInfo('passingTest');
+
+        // Two separate runs of the same method are distinct in-flight tests — their flows must differ so
+        // that, when interleaved, a consumer never merges their messages.
+        Assert::notSame($first->identity->id, $second->identity->id);
+
+        $a = self::capture(static fn(TeamcityLogger $logger) => $logger->testStartedFromInfo($first));
+        $b = self::capture(static fn(TeamcityLogger $logger) => $logger->testStartedFromInfo($second));
+
+        Assert::string($a)->contains("flowId='{$first->identity->id}'");
+        Assert::string($b)->contains("flowId='{$second->identity->id}'");
+    }
+
     /**
      * Runs the callback against a logger writing to an in-memory stream and returns what it wrote.
      *
diff --git a/tests/Sandbox/Self/AsyncTest.php b/tests/Sandbox/Self/AsyncTest.php
new file mode 100644
index 0000000..3ab9916
--- /dev/null
+++ b/tests/Sandbox/Self/AsyncTest.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Sandbox\Self;
+
+use Revolt\EventLoop;
+use Testo\Assert;
+use Testo\Bridge\Revolt\RunInRevolt;
+use Testo\Bridge\Revolt\Strategy;
+use Testo\Test;
+
+/**
+ * Async sandbox: several tests run at once on one Revolt loop ({@see Strategy::PerCase}), each doing a few
+ * steps of real work-and-sleep. Because they share the loop and sleep for different amounts, they
+ * interleave and finish in a staggered order — handy for eyeballing concurrent output.
+ */
+#[Test]
+#[RunInRevolt(Strategy::PerCase)]
+final class AsyncTest
+{
+    /**
+     * Per-test sleep step, in seconds. Each test naps this long between steps, so the shorter-napping
+     * tests finish well before the longer-napping ones.
+     *
+     * @var array<non-empty-string, float>
+     */
+    private const SLEEP_SECONDS = [
+        'quick' => 0.10,
+        'steady' => 0.20,
+        'slow' => 0.35,
+    ];
+
+    /** How many work-and-sleep steps each test performs. */
+    private const STEPS = 5;
+
+    public function quickBursts(): void
+    {
+        self::workThenSleep('quick');
+    }
+
+    public function steadyProgress(): void
+    {
+        self::workThenSleep('steady');
+    }
+
+    public function slowGrind(): void
+    {
+        self::workThenSleep('slow');
+    }
+
+    /**
+     * Do {@see STEPS} steps of "work" (an echoed progress line) separated by a real timer sleep of the
+     * `$label`'s duration, yielding the loop each time so the other tests run in between.
+     */
+    private static function workThenSleep(string $label): void
+    {
+        $step = self::SLEEP_SECONDS[$label];
+
+        $done = 0;
+        for ($i = 1; $i <= self::STEPS; $i++) {
+            self::sleep($step);
+            ++$done;
+            echo \sprintf("[%s] step %d/%d (slept %.2fs)\n", $label, $i, self::STEPS, $step);
+        }
+
+        Assert::same($done, self::STEPS);
+    }
+
+    /**
+     * Suspend this test's fiber for `$seconds` on the Revolt loop, letting the sibling tests run while it
+     * naps, then resume once the timer fires.
+     */
+    private static function sleep(float $seconds): void
+    {
+        $suspension = EventLoop::getSuspension();
+        EventLoop::delay($seconds, static fn() => $suspension->resume());
+        $suspension->suspend();
+    }
+}