diff --git a/tests/EndToEnd/README.md b/tests/EndToEnd/README.md
index cf734220..06fb0671 100644
--- a/tests/EndToEnd/README.md
+++ b/tests/EndToEnd/README.md
@@ -31,8 +31,12 @@ A script file declares `namespace Firehed\PhpLsp\Tests\EndToEnd;` and names type
   Run `composer install` in it before the suite.
   Each script runs against a throwaway copy, which becomes the server's working directory.
 - `capabilities` is what the client declares in `initialize`.
-- `Open` and `Type` are what a person does in the editor.
+  Declare watched-file support in any script that changes files on disk.
+- `Open`, `Type`, and `Close` are what a person does in the editor.
   Open only files a person would have open; the server finds the rest on its own.
+- `Copy` and `Delete` change the disk as another program would, and the server is not told.
+  `Copy` puts a prepared variant in place; variants live outside the autoload paths, such as `DiskChange/` in the fixture project.
+- `ReportChanges` is the client's file watcher reporting what changed, in one notification.
 - `Definition` and `Complete` are requests.
   Each decodes the answer, failing on a malformed one, and checks it against `expect:`: one expectation, or a list that must all hold.
 - Definition expectations are `LandsOn(file, line, column)`, where the column is optional, and `NoAnswer()`.
diff --git a/tests/EndToEnd/Session/Session.php b/tests/EndToEnd/Session/Session.php
index 324714d2..3ab6ca5c 100644
--- a/tests/EndToEnd/Session/Session.php
+++ b/tests/EndToEnd/Session/Session.php
@@ -7,6 +7,7 @@
 use Firehed\PhpLsp\Tests\EndToEnd\Client\LspClient;
 use Firehed\PhpLsp\Tests\EndToEnd\Client\ServerMessage;
 use Firehed\PhpLsp\Tests\EndToEnd\Marker\MarkerInterface;
+use Firehed\PhpLsp\Tests\EndToEnd\Step\FileChange;
 use PHPUnit\Framework\Assert;
 use stdClass;
 
@@ -54,6 +55,34 @@ public function ask(Feature $feature, string $file, MarkerInterface $at): Server
         return $response;
     }
 
+    public function close(string $file): void
+    {
+        assert(array_key_exists($file, $this->buffers), "Not open: {$file}");
+        unset($this->buffers[$file], $this->versions[$file]);
+
+        $this->client->notify('textDocument/didClose', (object) [
+            'textDocument' => ['uri' => $this->uri($file)],
+        ]);
+    }
+
+    /**
+     * Writes a file on disk as another process would. Nothing is sent.
+     */
+    public function copy(string $from, string $to): void
+    {
+        $copied = copy("{$this->projectRoot}/{$from}", "{$this->projectRoot}/{$to}");
+        assert($copied, "Cannot copy {$from} to {$to}");
+    }
+
+    /**
+     * Deletes a file on disk as another process would. Nothing is sent.
+     */
+    public function delete(string $file): void
+    {
+        $deleted = unlink("{$this->projectRoot}/{$file}");
+        assert($deleted, "Cannot delete {$file}");
+    }
+
     /**
      * @return ServerMessage The response to `shutdown`.
      */
@@ -91,6 +120,21 @@ public function open(string $file): void
         ]);
     }
 
+    /**
+     * Reports changes on disk, as the client's file watcher would.
+     *
+     * @param list<FileChange> $changes
+     */
+    public function reportChanges(array $changes): void
+    {
+        $this->client->notify('workspace/didChangeWatchedFiles', (object) [
+            'changes' => array_map(
+                fn (FileChange $change): array => ['uri' => $this->uri($change->file), 'type' => $change->type->value],
+                $changes,
+            ),
+        ]);
+    }
+
     /**
      * @return ServerMessage The response to `initialize`.
      */
diff --git a/tests/EndToEnd/Step/Close.php b/tests/EndToEnd/Step/Close.php
new file mode 100644
index 00000000..cf202f25
--- /dev/null
+++ b/tests/EndToEnd/Step/Close.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd\Step;
+
+use Firehed\PhpLsp\Tests\EndToEnd\Session\Session;
+
+final readonly class Close implements StepInterface
+{
+    /**
+     * @param string $file Path relative to the project root. It must be open.
+     */
+    public function __construct(private string $file)
+    {
+    }
+
+    public function run(Session $session): void
+    {
+        $session->close($this->file);
+    }
+}
diff --git a/tests/EndToEnd/Step/Copy.php b/tests/EndToEnd/Step/Copy.php
new file mode 100644
index 00000000..0f2067ed
--- /dev/null
+++ b/tests/EndToEnd/Step/Copy.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd\Step;
+
+use Firehed\PhpLsp\Tests\EndToEnd\Session\Session;
+
+/**
+ * Replaces or creates a file on disk with a prepared variant, as a checkout
+ * or a save in another program would. The server is not told.
+ */
+final readonly class Copy implements StepInterface
+{
+    /**
+     * @param string $from Path relative to the project root.
+     * @param string $to Path relative to the project root.
+     */
+    public function __construct(
+        private string $from,
+        private string $to,
+    ) {
+    }
+
+    public function run(Session $session): void
+    {
+        $session->copy($this->from, $this->to);
+    }
+}
diff --git a/tests/EndToEnd/Step/Delete.php b/tests/EndToEnd/Step/Delete.php
new file mode 100644
index 00000000..5672faec
--- /dev/null
+++ b/tests/EndToEnd/Step/Delete.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd\Step;
+
+use Firehed\PhpLsp\Tests\EndToEnd\Session\Session;
+
+/**
+ * Deletes a file on disk, as another program would. The server is not told.
+ */
+final readonly class Delete implements StepInterface
+{
+    /**
+     * @param string $file Path relative to the project root.
+     */
+    public function __construct(private string $file)
+    {
+    }
+
+    public function run(Session $session): void
+    {
+        $session->delete($this->file);
+    }
+}
diff --git a/tests/EndToEnd/Step/FileChange.php b/tests/EndToEnd/Step/FileChange.php
new file mode 100644
index 00000000..5cfe083e
--- /dev/null
+++ b/tests/EndToEnd/Step/FileChange.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd\Step;
+
+/**
+ * [LSP] workspace/didChangeWatchedFiles, FileEvent.
+ */
+final readonly class FileChange
+{
+    /**
+     * @param string $file Path relative to the project root.
+     */
+    public function __construct(
+        public string $file,
+        public FileChangeType $type,
+    ) {
+    }
+}
diff --git a/tests/EndToEnd/Step/FileChangeType.php b/tests/EndToEnd/Step/FileChangeType.php
new file mode 100644
index 00000000..a27138e3
--- /dev/null
+++ b/tests/EndToEnd/Step/FileChangeType.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd\Step;
+
+/**
+ * [LSP] workspace/didChangeWatchedFiles, FileChangeType.
+ */
+enum FileChangeType: int
+{
+    case Created = 1;
+    case Changed = 2;
+    case Deleted = 3;
+}
diff --git a/tests/EndToEnd/Step/ReportChanges.php b/tests/EndToEnd/Step/ReportChanges.php
new file mode 100644
index 00000000..5790c807
--- /dev/null
+++ b/tests/EndToEnd/Step/ReportChanges.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd\Step;
+
+use Firehed\PhpLsp\Tests\EndToEnd\Session\Session;
+
+/**
+ * The client's file watcher reporting what changed on disk, in one
+ * notification.
+ */
+final readonly class ReportChanges implements StepInterface
+{
+    /**
+     * @param list<FileChange> $changes
+     */
+    public function __construct(private array $changes)
+    {
+    }
+
+    public function run(Session $session): void
+    {
+        $session->reportChanges($this->changes);
+    }
+}
diff --git a/tests/EndToEnd/scripts/disk-autoload-files-edit.php b/tests/EndToEnd/scripts/disk-autoload-files-edit.php
new file mode 100644
index 00000000..9a2c8ea0
--- /dev/null
+++ b/tests/EndToEnd/scripts/disk-autoload-files-edit.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd;
+
+$consumer = 'src/DiskChange/Consumer.php';
+$helpers = 'AutoloadFiles/helpers.php';
+$helper = new Marker\SymbolMarker('helper_added');
+
+// Functions in an `autoload.files` entry are found through an index of that
+// file, which an edit must refresh.
+return new Session\Script(
+    project: 'tests/Fixtures',
+    steps: [
+        new Step\Definition($consumer, $helper, expect: new Expectation\NoAnswer()),
+        new Step\Copy('DiskChange/helpers.with-added.php', $helpers),
+        new Step\ReportChanges([new Step\FileChange($helpers, Step\FileChangeType::Changed)]),
+        new Step\Definition($consumer, $helper, expect: new Expectation\LandsOn($helpers, line: 11)),
+    ],
+    capabilities: new Session\ClientCapabilities(watchedFilesDynamicRegistration: true),
+);
diff --git a/tests/EndToEnd/scripts/disk-checkout.php b/tests/EndToEnd/scripts/disk-checkout.php
new file mode 100644
index 00000000..1a06c772
--- /dev/null
+++ b/tests/EndToEnd/scripts/disk-checkout.php
@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd;
+
+$consumer = 'src/DiskChange/Consumer.php';
+$widget = 'src/DiskChange/Widget.php';
+$gadget = 'src/DiskChange/Gadget.php';
+$greet = new Marker\SymbolMarker('widget_greet');
+$spin = new Marker\SymbolMarker('gadget_spin');
+
+// A checkout changes several files, reported together.
+return new Session\Script(
+    project: 'tests/Fixtures',
+    steps: [
+        new Step\Definition($consumer, $greet, expect: new Expectation\NoAnswer()),
+        new Step\Definition($consumer, $spin, expect: new Expectation\NoAnswer()),
+        new Step\Copy('DiskChange/Widget.with-greet.php', $widget),
+        new Step\Copy('DiskChange/Gadget.with-spin.php', $gadget),
+        new Step\ReportChanges([
+            new Step\FileChange($widget, Step\FileChangeType::Changed),
+            new Step\FileChange($gadget, Step\FileChangeType::Changed),
+        ]),
+        new Step\Definition($consumer, $greet, expect: new Expectation\LandsOn($widget, line: 12)),
+        new Step\Definition($consumer, $spin, expect: new Expectation\LandsOn($gadget, line: 12)),
+    ],
+    capabilities: new Session\ClientCapabilities(watchedFilesDynamicRegistration: true),
+);
diff --git a/tests/EndToEnd/scripts/disk-close-rereads.php b/tests/EndToEnd/scripts/disk-close-rereads.php
new file mode 100644
index 00000000..21f801af
--- /dev/null
+++ b/tests/EndToEnd/scripts/disk-close-rereads.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd;
+
+$consumer = 'src/DiskChange/Consumer.php';
+$widget = 'src/DiskChange/Widget.php';
+$greet = new Marker\SymbolMarker('widget_greet');
+
+// While a file is open its buffer wins over the disk ([LSP]
+// textDocument/didOpen). Closing it means the disk is read again, not the
+// answer from before it was opened.
+return new Session\Script(
+    project: 'tests/Fixtures',
+    steps: [
+        new Step\Definition($consumer, $greet, expect: new Expectation\NoAnswer()),
+        new Step\Open($widget),
+        new Step\Copy('DiskChange/Widget.with-greet.php', $widget),
+        new Step\Definition($consumer, $greet, expect: new Expectation\NoAnswer()),
+        new Step\Close($widget),
+        new Step\Definition($consumer, $greet, expect: new Expectation\LandsOn($widget, line: 12)),
+    ],
+    capabilities: new Session\ClientCapabilities(watchedFilesDynamicRegistration: true),
+);
diff --git a/tests/EndToEnd/scripts/disk-created-after-miss.php b/tests/EndToEnd/scripts/disk-created-after-miss.php
new file mode 100644
index 00000000..0003e099
--- /dev/null
+++ b/tests/EndToEnd/scripts/disk-created-after-miss.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd;
+
+$consumer = 'src/DiskChange/Consumer.php';
+$late = 'src/DiskChange/Late.php';
+$newLate = new Marker\SymbolMarker('new_late');
+
+// A class that was missing is not remembered as missing once it is created.
+return new Session\Script(
+    project: 'tests/Fixtures',
+    steps: [
+        new Step\Definition($consumer, $newLate, expect: new Expectation\NoAnswer()),
+        new Step\Copy('DiskChange/Late.php', $late),
+        new Step\ReportChanges([new Step\FileChange($late, Step\FileChangeType::Created)]),
+        new Step\Definition($consumer, $newLate, expect: new Expectation\LandsOn($late, line: 11)),
+    ],
+    capabilities: new Session\ClientCapabilities(watchedFilesDynamicRegistration: true),
+);
diff --git a/tests/EndToEnd/scripts/disk-deletion.php b/tests/EndToEnd/scripts/disk-deletion.php
new file mode 100644
index 00000000..2e64a9e6
--- /dev/null
+++ b/tests/EndToEnd/scripts/disk-deletion.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd;
+
+$consumer = 'src/DiskChange/Consumer.php';
+$widget = 'src/DiskChange/Widget.php';
+$newWidget = new Marker\SymbolMarker('new_widget');
+
+return new Session\Script(
+    project: 'tests/Fixtures',
+    steps: [
+        new Step\Definition($consumer, $newWidget, expect: new Expectation\LandsOn($widget, line: 11)),
+        new Step\Delete($widget),
+        new Step\ReportChanges([new Step\FileChange($widget, Step\FileChangeType::Deleted)]),
+        new Step\Definition($consumer, $newWidget, expect: new Expectation\NoAnswer()),
+    ],
+    capabilities: new Session\ClientCapabilities(watchedFilesDynamicRegistration: true),
+);
diff --git a/tests/EndToEnd/scripts/disk-reported-edit.php b/tests/EndToEnd/scripts/disk-reported-edit.php
new file mode 100644
index 00000000..e44175f6
--- /dev/null
+++ b/tests/EndToEnd/scripts/disk-reported-edit.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd;
+
+$consumer = 'src/DiskChange/Consumer.php';
+$widget = 'src/DiskChange/Widget.php';
+$greet = new Marker\SymbolMarker('widget_greet');
+
+// Another program edits a file the editor never opened.
+return new Session\Script(
+    project: 'tests/Fixtures',
+    steps: [
+        new Step\Definition($consumer, $greet, expect: new Expectation\NoAnswer()),
+        new Step\Copy('DiskChange/Widget.with-greet.php', $widget),
+        new Step\ReportChanges([new Step\FileChange($widget, Step\FileChangeType::Changed)]),
+        new Step\Definition($consumer, $greet, expect: new Expectation\LandsOn($widget, line: 12)),
+    ],
+    capabilities: new Session\ClientCapabilities(watchedFilesDynamicRegistration: true),
+);
diff --git a/tests/EndToEnd/scripts/disk-unreported-autoload-files-edit.php b/tests/EndToEnd/scripts/disk-unreported-autoload-files-edit.php
new file mode 100644
index 00000000..e0c66e50
--- /dev/null
+++ b/tests/EndToEnd/scripts/disk-unreported-autoload-files-edit.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd;
+
+$consumer = 'src/DiskChange/Consumer.php';
+$helper = new Marker\SymbolMarker('helper_added');
+
+// The index of `autoload.files` entries is rebuilt only when the editor
+// reports a change, so an unreported edit is not seen.
+return new Session\Script(
+    project: 'tests/Fixtures',
+    steps: [
+        new Step\Definition($consumer, $helper, expect: new Expectation\NoAnswer()),
+        new Step\Copy('DiskChange/helpers.with-added.php', 'AutoloadFiles/helpers.php'),
+        new Step\Definition($consumer, $helper, expect: new Expectation\NoAnswer()),
+    ],
+    capabilities: new Session\ClientCapabilities(watchedFilesDynamicRegistration: true),
+);
diff --git a/tests/EndToEnd/scripts/disk-unreported-class-edit.php b/tests/EndToEnd/scripts/disk-unreported-class-edit.php
new file mode 100644
index 00000000..1e19e1fb
--- /dev/null
+++ b/tests/EndToEnd/scripts/disk-unreported-class-edit.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Firehed\PhpLsp\Tests\EndToEnd;
+
+$consumer = 'src/DiskChange/Consumer.php';
+$widget = 'src/DiskChange/Widget.php';
+$greet = new Marker\SymbolMarker('widget_greet');
+
+// What a file declares is remembered by its text, so a class file is read
+// again on the next query and an unreported edit is still seen.
+return new Session\Script(
+    project: 'tests/Fixtures',
+    steps: [
+        new Step\Definition($consumer, $greet, expect: new Expectation\NoAnswer()),
+        new Step\Copy('DiskChange/Widget.with-greet.php', $widget),
+        new Step\Definition($consumer, $greet, expect: new Expectation\LandsOn($widget, line: 12)),
+    ],
+    capabilities: new Session\ClientCapabilities(watchedFilesDynamicRegistration: true),
+);
diff --git a/tests/Fixtures/DiskChange/Gadget.with-spin.php b/tests/Fixtures/DiskChange/Gadget.with-spin.php
new file mode 100644
index 00000000..5c4004a4
--- /dev/null
+++ b/tests/Fixtures/DiskChange/Gadget.with-spin.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fixtures\DiskChange;
+
+/**
+ * Copied over `src/DiskChange/Gadget.php` by end-to-end scripts.
+ */
+class Gadget
+{
+    public function spin(): void
+    {
+    }
+}
diff --git a/tests/Fixtures/DiskChange/Late.php b/tests/Fixtures/DiskChange/Late.php
new file mode 100644
index 00000000..716760ab
--- /dev/null
+++ b/tests/Fixtures/DiskChange/Late.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fixtures\DiskChange;
+
+/**
+ * Copied to `src/DiskChange/Late.php` by end-to-end scripts, creating a class
+ * the server first found missing.
+ */
+class Late
+{
+}
diff --git a/tests/Fixtures/DiskChange/Widget.with-greet.php b/tests/Fixtures/DiskChange/Widget.with-greet.php
new file mode 100644
index 00000000..01cd1ad7
--- /dev/null
+++ b/tests/Fixtures/DiskChange/Widget.with-greet.php
@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fixtures\DiskChange;
+
+/**
+ * Copied over `src/DiskChange/Widget.php` by end-to-end scripts.
+ */
+class Widget
+{
+    public function greet(): void
+    {
+    }
+}
diff --git a/tests/Fixtures/DiskChange/helpers.with-added.php b/tests/Fixtures/DiskChange/helpers.with-added.php
new file mode 100644
index 00000000..5fa61571
--- /dev/null
+++ b/tests/Fixtures/DiskChange/helpers.with-added.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fixtures\Helpers;
+
+/**
+ * Copied over `AutoloadFiles/helpers.php`, an `autoload.files` entry, by
+ * end-to-end scripts.
+ */
+function helperAdded(): void
+{
+}
diff --git a/tests/Fixtures/src/DiskChange/Consumer.php b/tests/Fixtures/src/DiskChange/Consumer.php
new file mode 100644
index 00000000..a64669f1
--- /dev/null
+++ b/tests/Fixtures/src/DiskChange/Consumer.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fixtures\DiskChange;
+
+use function Fixtures\Helpers\helperAdded;
+
+/**
+ * Uses names that only exist once an end-to-end script has changed files on
+ * disk.
+ */
+class Consumer
+{
+    public function useWidget(Widget $widget): void
+    {
+        $widget->greet(); //hover:widget_greet
+    }
+
+    public function useGadget(Gadget $gadget): void
+    {
+        $gadget->spin(); //hover:gadget_spin
+    }
+
+    public function makeWidget(): void
+    {
+        new Widget(); //hover:new_widget
+    }
+
+    public function makeLate(): void
+    {
+        new Late(); //hover:new_late
+    }
+
+    public function useHelper(): void
+    {
+        helperAdded(); //hover:helper_added
+    }
+}
diff --git a/tests/Fixtures/src/DiskChange/Gadget.php b/tests/Fixtures/src/DiskChange/Gadget.php
new file mode 100644
index 00000000..9ce50289
--- /dev/null
+++ b/tests/Fixtures/src/DiskChange/Gadget.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fixtures\DiskChange;
+
+/**
+ * End-to-end scripts replace this file on disk with a variant from the
+ * top-level `DiskChange/` directory.
+ */
+class Gadget
+{
+}
diff --git a/tests/Fixtures/src/DiskChange/Widget.php b/tests/Fixtures/src/DiskChange/Widget.php
new file mode 100644
index 00000000..4809b0eb
--- /dev/null
+++ b/tests/Fixtures/src/DiskChange/Widget.php
@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Fixtures\DiskChange;
+
+/**
+ * End-to-end scripts replace this file on disk with a variant from the
+ * top-level `DiskChange/` directory.
+ */
+class Widget
+{
+}
diff --git a/tests/Integration/DefinitionIntegrationTest.php b/tests/Integration/DefinitionIntegrationTest.php
deleted file mode 100644
index 0555c7d2..00000000
--- a/tests/Integration/DefinitionIntegrationTest.php
+++ /dev/null
@@ -1,164 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Firehed\PhpLsp\Tests\Integration;
-
-use Amp\ByteStream\ReadableBuffer;
-use Amp\ByteStream\WritableBuffer;
-use Firehed\PhpLsp\Protocol\Message;
-use Firehed\PhpLsp\Protocol\OutgoingMessageInterface;
-use Firehed\PhpLsp\Protocol\ServerInfo;
-use Firehed\PhpLsp\Server;
-use Firehed\PhpLsp\Tests\BuildsContainerTrait;
-use Firehed\PhpLsp\Transport\EndOfStream;
-use Firehed\PhpLsp\Transport\MalformedFrame;
-use Firehed\PhpLsp\Transport\MessageReader;
-use Firehed\PhpLsp\Transport\MessageWriter;
-use Firehed\PhpLsp\Transport\TransportInterface;
-use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\TestCase;
-
-#[CoversClass(Server::class)]
-class DefinitionIntegrationTest extends TestCase
-{
-    use BuildsContainerTrait;
-
-    public function testGoToDefinitionEndToEnd(): void
-    {
-        // Simulate full LSP interaction:
-        // 1. Initialize
-        // 2. Open file with class definition
-        // 3. Open file with class usage
-        // 4. Request definition
-        // 5. Shutdown + exit
-
-        $messages = [
-            // Initialize
-            $this->makeRequest(1, 'initialize', [
-                'processId' => getmypid(),
-                'capabilities' => [],
-                'rootUri' => 'file:///project',
-            ]),
-            // Initialized notification
-            $this->makeNotification('initialized', []),
-            // Open class definition file
-            $this->makeNotification('textDocument/didOpen', [
-                'textDocument' => [
-                    'uri' => 'file:///project/src/MyClass.php',
-                    'languageId' => 'php',
-                    'version' => 1,
-                    'text' => '<?php class MyClass { public function hello() {} }',
-                ],
-            ]),
-            // Open usage file
-            $this->makeNotification('textDocument/didOpen', [
-                'textDocument' => [
-                    'uri' => 'file:///project/src/usage.php',
-                    'languageId' => 'php',
-                    'version' => 1,
-                    'text' => '<?php $x = new MyClass();',
-                ],
-            ]),
-            // Request definition at "MyClass" in usage.php
-            $this->makeRequest(2, 'textDocument/definition', [
-                'textDocument' => ['uri' => 'file:///project/src/usage.php'],
-                'position' => ['line' => 0, 'character' => 15], // On "MyClass"
-            ]),
-            // Shutdown
-            $this->makeRequest(3, 'shutdown', null),
-            // Exit
-            $this->makeNotification('exit', null),
-        ];
-
-        $input = implode('', array_map(fn($m) => $this->encode($m), $messages));
-        $outputBuffer = new WritableBuffer();
-
-        $transport = $this->createTransport($input, $outputBuffer);
-        $server = Server::forProject($transport, new ServerInfo('test', '1.0'), $this->buildContainer());
-
-        $exitCode = $server->run();
-
-        self::assertSame(0, $exitCode);
-
-        $output = $outputBuffer->buffer();
-
-        // Parse responses
-        self::assertStringContainsString('"id":2', $output, 'Should have response to definition request');
-        // JSON escapes / as \/ so check for that
-        self::assertStringContainsString('MyClass.php', $output, 'Definition should point to MyClass.php');
-    }
-
-    /**
-     * @param array<string, mixed>|null $params
-     * @return array<string, mixed>
-     */
-    private function makeRequest(int $id, string $method, ?array $params): array
-    {
-        $msg = [
-            'jsonrpc' => '2.0',
-            'id' => $id,
-            'method' => $method,
-        ];
-        if ($params !== null) {
-            $msg['params'] = $params;
-        }
-        return $msg;
-    }
-
-    /**
-     * @param array<string, mixed>|null $params
-     * @return array<string, mixed>
-     */
-    private function makeNotification(string $method, ?array $params): array
-    {
-        $msg = [
-            'jsonrpc' => '2.0',
-            'method' => $method,
-        ];
-        if ($params !== null) {
-            $msg['params'] = $params;
-        }
-        return $msg;
-    }
-
-    /**
-     * @param array<string, mixed> $message
-     */
-    private function encode(array $message): string
-    {
-        $json = json_encode($message, JSON_THROW_ON_ERROR);
-        return "Content-Length: " . strlen($json) . "\r\n\r\n" . $json;
-    }
-
-    private function createTransport(string $input, WritableBuffer $outputBuffer): TransportInterface
-    {
-        $inputBuffer = new ReadableBuffer($input);
-        $reader = new MessageReader($inputBuffer);
-        $writer = new MessageWriter($outputBuffer);
-
-        return new class ($reader, $writer, $outputBuffer) implements TransportInterface {
-            public function __construct(
-                private MessageReader $reader,
-                private MessageWriter $writer,
-                private WritableBuffer $outputBuffer,
-            ) {
-            }
-
-            public function read(): Message|MalformedFrame|EndOfStream
-            {
-                return $this->reader->read();
-            }
-
-            public function write(OutgoingMessageInterface $message): void
-            {
-                $this->writer->write($message);
-            }
-
-            public function close(): void
-            {
-                $this->outputBuffer->close();
-            }
-        };
-    }
-}
diff --git a/tests/Integration/ExternalFileChangeInvalidationTest.php b/tests/Integration/ExternalFileChangeInvalidationTest.php
deleted file mode 100644
index c1169490..00000000
--- a/tests/Integration/ExternalFileChangeInvalidationTest.php
+++ /dev/null
@@ -1,302 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Firehed\PhpLsp\Tests\Integration;
-
-use Firehed\PhpLsp\Document\DocumentManager;
-use Firehed\PhpLsp\Domain\CatalogSymbol;
-use Firehed\PhpLsp\Domain\ClasslikeName;
-use Firehed\PhpLsp\Domain\ComposerAutoloadMap;
-use Firehed\PhpLsp\Domain\NamespaceName;
-use Firehed\PhpLsp\Handler\DidChangeWatchedFilesHandler;
-use Firehed\PhpLsp\Handler\TextDocumentSyncHandler;
-use Firehed\PhpLsp\Knowledge\KnowledgeStack;
-use Firehed\PhpLsp\Knowledge\SymbolSourceInterface;
-use Firehed\PhpLsp\Protocol\NotificationMessage;
-use Firehed\PhpLsp\Tests\BuildsKnowledgeStackTrait;
-use Firehed\PhpLsp\Tests\Parser\ProductionSyntaxSource;
-use PHPUnit\Framework\Attributes\CoversNothing;
-use PHPUnit\Framework\TestCase;
-
-/**
- * External-change invalidation end to end (RFC 1 §5.2, §5.3):
- * against a real on-disk workspace, an external edit to an unopened file, a branch
- * checkout, and a deletion are each reflected on the next query, and closing an
- * edited file re-reads from disk rather than restoring the pre-edit cache.
- *
- * The change notifications drive the real handler → {@see \Firehed\PhpLsp\Cache\InvalidatableInterface}
- * fan-out → backend chain; the workspace is a temp directory mutated between queries.
- */
-#[CoversNothing]
-class ExternalFileChangeInvalidationTest extends TestCase
-{
-    use BuildsKnowledgeStackTrait;
-
-    private const string NAMESPACE = 'Temp\\';
-
-    private string $workspace;
-    private ProductionSyntaxSource $syntax;
-
-    protected function setUp(): void
-    {
-        $workspace = tempnam(sys_get_temp_dir(), 'php-lsp-s35-');
-        self::assertNotFalse($workspace, 'a temp workspace path must be obtainable');
-        unlink($workspace);
-        self::assertTrue(mkdir($workspace), 'the temp workspace directory must be created');
-
-        $this->workspace = $workspace;
-        $this->syntax = ProductionSyntaxSource::create();
-    }
-
-    protected function tearDown(): void
-    {
-        $files = glob($this->workspace . '/*');
-        if ($files !== false) {
-            foreach ($files as $file) {
-                unlink($file);
-            }
-        }
-        rmdir($this->workspace);
-    }
-
-    public function testAnExternalEditToAnUnopenedFileIsReflectedOnTheNextQuery(): void
-    {
-        $this->writeClass('Widget', '');
-        $stack = $this->stack();
-        $handler = new DidChangeWatchedFilesHandler($stack->invalidator);
-
-        $before = $stack->source->lookupClassLike($this->classNameFor('Widget'));
-        self::assertNotNull($before, 'the unopened workspace class must resolve from disk');
-        self::assertArrayNotHasKey('greet', $before->methods, 'the original file declares no greet() method');
-
-        $this->writeClass('Widget', 'public function greet(): void {}');
-        $handler->handle($this->changed('Widget'));
-
-        $after = $stack->source->lookupClassLike($this->classNameFor('Widget'));
-        self::assertNotNull($after, 'the class still resolves after the edit');
-        self::assertArrayHasKey(
-            'greet',
-            $after->methods,
-            'the external edit must be reflected on the next query rather than serving the cached class',
-        );
-    }
-
-    public function testABranchCheckoutIsReflectedOnTheNextQuery(): void
-    {
-        // A checkout changes several files at once; the client reports one event per file.
-        $this->writeClass('Alpha', '');
-        $this->writeClass('Beta', '');
-        $stack = $this->stack();
-        $handler = new DidChangeWatchedFilesHandler($stack->invalidator);
-
-        $this->warm($stack->source, 'Alpha', 'Beta');
-
-        $this->writeClass('Alpha', 'public function onAlpha(): void {}');
-        $this->writeClass('Beta', 'public function onBeta(): void {}');
-        $handler->handle($this->changed('Alpha', 'Beta'));
-
-        $alpha = $stack->source->lookupClassLike($this->classNameFor('Alpha'));
-        $beta = $stack->source->lookupClassLike($this->classNameFor('Beta'));
-        self::assertNotNull($alpha);
-        self::assertNotNull($beta);
-        self::assertArrayHasKey('onAlpha', $alpha->methods, 'each checked-out file must be re-read');
-        self::assertArrayHasKey('onBeta', $beta->methods, 'each checked-out file must be re-read');
-    }
-
-    public function testAFileDeletionIsReflectedOnTheNextQuery(): void
-    {
-        $this->writeClass('Widget', '');
-        $stack = $this->stack();
-        $handler = new DidChangeWatchedFilesHandler($stack->invalidator);
-
-        self::assertNotNull(
-            $stack->source->lookupClassLike($this->classNameFor('Widget')),
-            'the class resolves while its file exists',
-        );
-
-        unlink($this->workspace . '/Widget.php');
-        $handler->handle($this->changed('Widget'));
-
-        self::assertNull(
-            $stack->source->lookupClassLike($this->classNameFor('Widget')),
-            'a deleted file must resolve to nothing on the next query, not the cached class',
-        );
-    }
-
-    public function testAClassCreatedAfterAFailedLookupResolvesOnTheNextQuery(): void
-    {
-        $stack = $this->stack();
-        $handler = new DidChangeWatchedFilesHandler($stack->invalidator);
-
-        self::assertNull(
-            $stack->source->lookupClassLike($this->classNameFor('Late')),
-            'the class does not exist yet',
-        );
-
-        $this->writeClass('Late', '');
-        $handler->handle($this->changed('Late'));
-
-        self::assertNotNull(
-            $stack->source->lookupClassLike($this->classNameFor('Late')),
-            'a file created after a miss must resolve on the next query, not stay remembered as missing',
-        );
-    }
-
-    public function testClosingAnEditedFileReReadsFromDiskRatherThanRestoringThePreEditCache(): void
-    {
-        $this->writeClass('Widget', '');
-        $stack = $this->stack();
-        $uri = $this->uriFor('Widget');
-        $documents = new DocumentManager();
-        $sync = new TextDocumentSyncHandler($documents, $stack->sink, $stack->invalidator);
-
-        // The file is cached from disk, then opened and edited in the editor and
-        // saved to disk with a new method.
-        self::assertNotNull($stack->source->lookupClassLike($this->classNameFor('Widget')));
-        $sync->handle($this->didOpen($uri, $this->classSource('Widget', '')));
-        $this->writeClass('Widget', 'public function saved(): void {}');
-
-        $sync->handle($this->didClose($uri));
-
-        $reopened = $stack->source->lookupClassLike($this->classNameFor('Widget'));
-        self::assertNotNull($reopened, 'the class still resolves from disk after close');
-        self::assertArrayHasKey(
-            'saved',
-            $reopened->methods,
-            'closing an edited file must re-read disk, not restore the pre-edit cached class (RFC 1 §5.3)',
-        );
-    }
-
-    /**
-     * Two derived structures stand between an `autoload.files` entry and a
-     * completion list — the name -> file index and the cached namespace listing —
-     * and either one left stale hides the edit. Enumeration is held to the same
-     * next-query rule as lookup (RFC 1 §5.2, §5.3).
-     */
-    public function testAnExternalEditToAnAutoloadFilesEntryIsReflectedInEnumeration(): void
-    {
-        $path = $this->workspace . '/bootstrap.php';
-        $this->writeFile($path, "<?php\nnamespace Temp;\nclass FilesBefore {}\n");
-
-        $stack = $this->knowledgeStackForMap(
-            new ComposerAutoloadMap(files: [$path]),
-            $this->syntax,
-        );
-        $handler = new DidChangeWatchedFilesHandler($stack->invalidator);
-
-        self::assertSame(
-            ['Temp\FilesBefore'],
-            $this->enumerate($stack->source),
-            'the class the entry declares must be enumerated before the edit',
-        );
-
-        $this->writeFile($path, "<?php\nnamespace Temp;\nclass FilesAfter {}\n");
-        $handler->handle($this->changed('bootstrap'));
-
-        self::assertSame(
-            ['Temp\FilesAfter'],
-            $this->enumerate($stack->source),
-            'the edit must reach both the derived index and the cached namespace listing',
-        );
-    }
-
-    /**
-     * @return list<string>
-     */
-    private function enumerate(SymbolSourceInterface $source): array
-    {
-        return array_map(
-            static fn(CatalogSymbol $symbol): string => $symbol->fullyQualifiedName,
-            $source->childrenOf(new NamespaceName('Temp'))->symbols,
-        );
-    }
-
-    private function writeFile(string $path, string $contents): void
-    {
-        self::assertNotFalse(file_put_contents($path, $contents), "the fixture file {$path} must be writable");
-    }
-
-    private function warm(SymbolSourceInterface $source, string ...$shortNames): void
-    {
-        foreach ($shortNames as $shortName) {
-            self::assertNotNull(
-                $source->lookupClassLike($this->classNameFor($shortName)),
-                "{$shortName} must resolve so its pre-change value is cached",
-            );
-        }
-    }
-
-    private function stack(): KnowledgeStack
-    {
-        return $this->knowledgeStackForMap(
-            new ComposerAutoloadMap(psr4: [self::NAMESPACE => [$this->workspace]]),
-            $this->syntax,
-        );
-    }
-
-    private function writeClass(string $shortName, string $body): void
-    {
-        self::assertNotFalse(
-            file_put_contents($this->workspace . '/' . $shortName . '.php', $this->classSource($shortName, $body)),
-            "the fixture class {$shortName} must be writable",
-        );
-    }
-
-    private function classSource(string $shortName, string $body): string
-    {
-        return "<?php\nnamespace Temp;\nclass {$shortName} {\n{$body}\n}\n";
-    }
-
-    private function didOpen(string $uri, string $text): NotificationMessage
-    {
-        return NotificationMessage::fromArray([
-            'jsonrpc' => '2.0',
-            'method' => 'textDocument/didOpen',
-            'params' => [
-                'textDocument' => [
-                    'uri' => $uri,
-                    'languageId' => 'php',
-                    'version' => 1,
-                    'text' => $text,
-                ],
-            ],
-        ]);
-    }
-
-    private function didClose(string $uri): NotificationMessage
-    {
-        return NotificationMessage::fromArray([
-            'jsonrpc' => '2.0',
-            'method' => 'textDocument/didClose',
-            'params' => [
-                'textDocument' => ['uri' => $uri],
-            ],
-        ]);
-    }
-
-    private function changed(string ...$shortNames): NotificationMessage
-    {
-        $changes = [];
-        foreach ($shortNames as $shortName) {
-            // FileChangeType.Changed = 2; the handler treats every type alike.
-            $changes[] = ['uri' => $this->uriFor($shortName), 'type' => 2];
-        }
-
-        return NotificationMessage::fromArray([
-            'jsonrpc' => '2.0',
-            'method' => 'workspace/didChangeWatchedFiles',
-            'params' => ['changes' => $changes],
-        ]);
-    }
-
-    private function uriFor(string $shortName): string
-    {
-        return 'file://' . $this->workspace . '/' . $shortName . '.php';
-    }
-
-    private function classNameFor(string $shortName): ClasslikeName
-    {
-        return ClasslikeName::fromFullyQualified('Temp\\' . $shortName);
-    }
-}
diff --git a/tests/ServerTest.php b/tests/ServerTest.php
index 6cb74164..2efdde6b 100644
--- a/tests/ServerTest.php
+++ b/tests/ServerTest.php
@@ -31,75 +31,6 @@ class ServerTest extends TestCase
     use BuildsContainerTrait;
     use LoadsFixturesTrait;
 
-    /**
-     * The composed server must route an inbound `workspace/didChangeWatchedFiles`
-     * notification to the invalidation handler (RFC 1 §5.2, §5.3). The handler and
-     * its sink→backend chain are proven in isolation elsewhere; this is the only
-     * test that drives the notification through `Server::run()`, so it guards the
-     * `forProject` wiring itself. Dropping the handler from the dispatch list leaves
-     * the second completion serving the stale cached class — which this catches.
-     */
-    public function testDidChangeWatchedFilesInvalidatesWorkspaceStateThroughTheComposedServer(): void
-    {
-        $root = $this->createProject('public function original(): void {}');
-        $consumerUri = 'file://' . $root . '/src/consumer.php';
-        $consumer = "<?php\nnamespace Temp;\n\$w = new Widget();\n\$w->\n";
-
-        try {
-            $input = $this->buildMessages(
-                $this->initializeJson(1),
-                $this->initializedJson(),
-                $this->notificationJson('textDocument/didOpen', [
-                    'textDocument' => [
-                        'uri' => $consumerUri,
-                        'languageId' => 'php',
-                        'version' => 1,
-                        'text' => $consumer,
-                    ],
-                ]),
-                $this->completionAt(2, $consumerUri),
-                // The client saves a new method to the unopened workspace file and
-                // reports the change; the next completion must reflect it.
-                $this->notificationJson('workspace/didChangeWatchedFiles', [
-                    'changes' => [['uri' => 'file://' . $root . '/src/Widget.php', 'type' => 2]],
-                ]),
-                $this->completionAt(3, $consumerUri),
-                $this->requestJson(4, 'shutdown'),
-                $this->notificationJson('exit'),
-            );
-
-            $outputBuffer = new WritableBuffer();
-            // The whole message stream is buffered, so the disk edit is applied as
-            // the transport surfaces the watched-files frame — after the first
-            // completion is answered and before the second is read.
-            $transport = $this->createTransport($input, $outputBuffer, function (Message $message) use ($root): void {
-                if ($message->method === 'workspace/didChangeWatchedFiles') {
-                    $this->writeWidget(
-                        $root,
-                        "public function original(): void {}\n    public function added(): void {}",
-                    );
-                }
-            });
-            $server = Server::forProject($transport, new ServerInfo('test', '1.0'), $this->buildContainer(), $root);
-
-            $server->run();
-
-            $responses = $this->decodeResponses($outputBuffer->buffer());
-            $before = $this->completionLabels($this->responseWithId($responses, 2));
-            $after = $this->completionLabels($this->responseWithId($responses, 3));
-
-            self::assertContains('original', $before, 'the first completion resolves the workspace class from disk');
-            self::assertNotContains('added', $before, 'the new method does not exist when the first completion runs');
-            self::assertContains(
-                'added',
-                $after,
-                'the watched-files notification must invalidate the cached class so the edit is reflected',
-            );
-        } finally {
-            $this->removeProject($root);
-        }
-    }
-
     public function testUnknownMethodReturnsError(): void
     {
         $input = $this->buildMessages(
@@ -745,84 +676,6 @@ private function countRequests(array $jsonMessages): int
         return $count;
     }
 
-    /**
-     * A minimal on-disk project `Server::forProject` can resolve: the generated
-     * Composer PSR-4 map (`Temp\` => `src/`) plus a `Widget` class with the given
-     * method body. Returned path is the project root.
-     */
-    private function createProject(string $widgetBody): string
-    {
-        $root = tempnam(sys_get_temp_dir(), 'php-lsp-srv-');
-        self::assertNotFalse($root, 'a temp project path must be obtainable');
-        unlink($root);
-
-        foreach (['/src', '/vendor/composer'] as $dir) {
-            self::assertTrue(mkdir($root . $dir, 0777, true), "the {$dir} directory must be created");
-        }
-
-        self::assertNotFalse(
-            file_put_contents(
-                $root . '/vendor/composer/autoload_psr4.php',
-                "<?php\nreturn " . var_export(['Temp\\' => [$root . '/src']], true) . ";\n",
-            ),
-            'the generated PSR-4 map must be writable',
-        );
-        $this->writeWidget($root, $widgetBody);
-
-        return $root;
-    }
-
-    private function writeWidget(string $root, string $body): void
-    {
-        self::assertNotFalse(
-            file_put_contents($root . '/src/Widget.php', "<?php\nnamespace Temp;\nclass Widget {\n    {$body}\n}\n"),
-            'the workspace Widget class must be writable',
-        );
-    }
-
-    private function removeProject(string $root): void
-    {
-        foreach (['/src/consumer.php', '/src/Widget.php', '/vendor/composer/autoload_psr4.php'] as $file) {
-            if (file_exists($root . $file)) {
-                unlink($root . $file);
-            }
-        }
-        foreach (['/src', '/vendor/composer', '/vendor', ''] as $dir) {
-            rmdir($root . $dir);
-        }
-    }
-
-    private function completionAt(int $id, string $uri): string
-    {
-        // The consumer's `$w->` sits at line 3, immediately after the `->`.
-        return $this->requestJson($id, 'textDocument/completion', [
-            'textDocument' => ['uri' => $uri],
-            'position' => ['line' => 3, 'character' => 4],
-        ]);
-    }
-
-    /**
-     * @param array<array-key, mixed> $response
-     * @return list<string>
-     */
-    private function completionLabels(array $response): array
-    {
-        $result = $response['result'] ?? null;
-        self::assertIsArray($result, 'a completion response carries a result');
-        $items = $result['items'] ?? null;
-        self::assertIsArray($items, 'a completion result carries an items list');
-
-        $labels = [];
-        foreach ($items as $item) {
-            self::assertIsArray($item, 'each completion item is an object');
-            $label = $item['label'] ?? null;
-            self::assertIsString($label, 'each completion item carries a label');
-            $labels[] = $label;
-        }
-
-        return $labels;
-    }
-
     private function initializeJson(int $id = 1): string
     {
         return $this->requestJson($id, 'initialize', ['processId' => 1234, 'capabilities' => []]);
@@ -938,39 +791,23 @@ private function serverWith(TransportInterface $transport, array $handlers = [])
         );
     }
 
-    /**
-     * @param (\Closure(Message): void)|null $afterRead Invoked with each read
-     *        message, so a test can apply an out-of-band side effect (e.g. a disk
-     *        edit) at a known point in the otherwise-buffered stream.
-     */
-    private function createTransport(
-        string $input,
-        WritableBuffer $outputBuffer,
-        ?\Closure $afterRead = null,
-    ): TransportInterface {
+    private function createTransport(string $input, WritableBuffer $outputBuffer): TransportInterface
+    {
         $inputBuffer = new ReadableBuffer($input);
         $reader = new MessageReader($inputBuffer);
         $writer = new MessageWriter($outputBuffer);
 
-        return new class ($reader, $writer, $outputBuffer, $afterRead) implements TransportInterface {
-            /**
-             * @param (\Closure(Message): void)|null $afterRead
-             */
+        return new class ($reader, $writer, $outputBuffer) implements TransportInterface {
             public function __construct(
                 private MessageReader $reader,
                 private MessageWriter $writer,
                 private WritableBuffer $outputBuffer,
-                private ?\Closure $afterRead,
             ) {
             }
 
             public function read(): Message|MalformedFrame|EndOfStream
             {
-                $message = $this->reader->read();
-                if ($message instanceof Message && $this->afterRead !== null) {
-                    ($this->afterRead)($message);
-                }
-                return $message;
+                return $this->reader->read();
             }
 
             public function write(\Firehed\PhpLsp\Protocol\OutgoingMessageInterface $message): void