feat(plugin): activate plugins through the PHP RPC worker

Implement the remainder of PluginManager::registerPackage: the plugin
autoload map is built by the ported createLoader/parseAutoloads and
served to the worker over the existing reverse-RPC autoloader, files
entries go through a composerRequire-equivalent glue call, and
already-defined classes take the upstream _composer_tmp rename/eval
path. Instantiation uses the new NewObject/CallPhpMethod lanes backed
by a P table in the worker; PhpPluginProxy adapts the resulting handle
to PluginInterface, with $composer/$io exposed to plugin callbacks via
an R table (unsupported methods stay explicit errors). Hand-written
proxy stubs cover Composer, PartialComposer and the IO hierarchy, and
the stub autoloader is re-prepended after loading the Composer PHP
runtime so its vendor autoloader cannot shadow proxied FQCNs.

FilesystemRepository::write now mirrors InstalledVersions::reload into
a running worker (class_exists-guarded, so an unloaded class keeps its
upstream lazy-load behavior), removing the previously undefined
observation window.

The installer pipeline passes the installed repository as a shared
handle instead of a long-lived `&mut dyn`: plugin registration runs
inside InstallationManager::execute and re-enters the same local
repository through the RepositoryManager, which would panic on the
RefCell re-borrow under the old shape.

PluginInterface lifecycle methods now take an owned ComposerHandle
(plugins retain $composer past the call) and return anyhow::Result
(PHP plugin code may throw); the plugin list uses shared ownership so
the identity comparison of removePlugin survives the dual storage in
registeredPlugins, matching PHP reference semantics.

Ports the activate/upgrade/uninstall tests of PluginInstallerTest,
serialized across the shared worker process whose persistent class
table is exactly what exercises the rename path.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

7 files changed, 576 insertions, 17 deletions

diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/Composer.php b/crates/shirabe-php-rpc/php/stubs/Composer/Composer.php
new file mode 100644
index 00000000..1bb9f64c
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/stubs/Composer/Composer.php
@@ -0,0 +1,88 @@
+<?php
+
+// Hand-written proxy stub for Composer\Composer, kept in the shape the future stub generator
+// will output. Class constants and static methods are materialized (they read no instance
+// state); instance methods forward to the Rust-side entity.
+
+namespace Composer;
+
+use Composer\Autoload\AutoloadGenerator;
+use Composer\Package\Archiver\ArchiveManager;
+use Composer\Package\Locker;
+use Composer\Downloader\DownloadManager;
+use Composer\Pcre\Preg;
+use Composer\Plugin\PluginManager;
+
+class Composer extends PartialComposer
+{
+    public const VERSION = '2.9.7';
+    public const BRANCH_ALIAS_VERSION = '';
+    public const RELEASE_DATE = '2026-04-14 13:31:52';
+    public const SOURCE_VERSION = '';
+    public const RUNTIME_API_VERSION = '2.2.2';
+
+    public static function getVersion(): string
+    {
+        // no replacement done, this must be a source checkout
+        if (self::VERSION === '@package_version'.'@') {
+            return self::SOURCE_VERSION;
+        }
+
+        // we have a branch alias and version is a commit id, this must be a snapshot build
+        if (self::BRANCH_ALIAS_VERSION !== '' && Preg::isMatch('{^[a-f0-9]{40}$}', self::VERSION)) {
+            return self::BRANCH_ALIAS_VERSION.'+'.self::VERSION;
+        }
+
+        return self::VERSION;
+    }
+
+    public function setLocker(Locker $locker): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setLocker', [$locker]);
+    }
+
+    public function getLocker(): Locker
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getLocker', []);
+    }
+
+    public function setDownloadManager(DownloadManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setDownloadManager', [$manager]);
+    }
+
+    public function getDownloadManager(): DownloadManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getDownloadManager', []);
+    }
+
+    public function setArchiveManager(ArchiveManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setArchiveManager', [$manager]);
+    }
+
+    public function getArchiveManager(): ArchiveManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getArchiveManager', []);
+    }
+
+    public function setPluginManager(PluginManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setPluginManager', [$manager]);
+    }
+
+    public function getPluginManager(): PluginManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getPluginManager', []);
+    }
+
+    public function setAutoloadGenerator(AutoloadGenerator $autoloadGenerator): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setAutoloadGenerator', [$autoloadGenerator]);
+    }
+
+    public function getAutoloadGenerator(): AutoloadGenerator
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getAutoloadGenerator', []);
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/IO/BaseIO.php b/crates/shirabe-php-rpc/php/stubs/Composer/IO/BaseIO.php
new file mode 100644
index 00000000..3a268c22
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/stubs/Composer/IO/BaseIO.php
@@ -0,0 +1,193 @@
+<?php
+
+// Hand-written proxy stub for Composer\IO\BaseIO, kept in the shape the future stub generator
+// will output: every public method of the real class (its own and the IOInterface /
+// LoggerInterface surface) forwards to the Rust-side entity. Loading this stub pulls the real
+// IOInterface contract from the Composer PHP runtime, which must already be required.
+
+namespace Composer\IO;
+
+use Composer\Config;
+
+abstract class BaseIO implements IOInterface, \ShirabeRustStub
+{
+    /** @var int */
+    protected $__rhandle;
+    /** @var int */
+    protected $__epoch;
+
+    public function __construct(int $rhandle, int $epoch)
+    {
+        $this->__rhandle = $rhandle;
+        $this->__epoch = $epoch;
+    }
+
+    public function __destruct()
+    {
+        \ShirabeRustObjectRegistry::release($this->__rhandle);
+    }
+
+    public function __shirabeRustHandleDescriptor(): array
+    {
+        return [
+            '__rhandle' => $this->__rhandle,
+            '__class' => static::class,
+            '__epoch' => $this->__epoch,
+        ];
+    }
+
+    public function isInteractive()
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isInteractive', []);
+    }
+
+    public function isVerbose()
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isVerbose', []);
+    }
+
+    public function isVeryVerbose()
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isVeryVerbose', []);
+    }
+
+    public function isDebug()
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isDebug', []);
+    }
+
+    public function isDecorated()
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isDecorated', []);
+    }
+
+    public function write($messages, bool $newline = true, int $verbosity = self::NORMAL)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'write', [$messages, $newline, $verbosity]);
+    }
+
+    public function writeError($messages, bool $newline = true, int $verbosity = self::NORMAL)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'writeError', [$messages, $newline, $verbosity]);
+    }
+
+    public function writeRaw($messages, bool $newline = true, int $verbosity = self::NORMAL)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'writeRaw', [$messages, $newline, $verbosity]);
+    }
+
+    public function writeErrorRaw($messages, bool $newline = true, int $verbosity = self::NORMAL)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'writeErrorRaw', [$messages, $newline, $verbosity]);
+    }
+
+    public function overwrite($messages, bool $newline = true, ?int $size = null, int $verbosity = self::NORMAL)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'overwrite', [$messages, $newline, $size, $verbosity]);
+    }
+
+    public function overwriteError($messages, bool $newline = true, ?int $size = null, int $verbosity = self::NORMAL)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'overwriteError', [$messages, $newline, $size, $verbosity]);
+    }
+
+    public function ask(string $question, $default = null)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'ask', [$question, $default]);
+    }
+
+    public function askConfirmation(string $question, bool $default = true)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'askConfirmation', [$question, $default]);
+    }
+
+    public function askAndValidate(string $question, callable $validator, ?int $attempts = null, $default = null)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'askAndValidate', [$question, $validator, $attempts, $default]);
+    }
+
+    public function askAndHideAnswer(string $question)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'askAndHideAnswer', [$question]);
+    }
+
+    public function select(string $question, array $choices, $default, $attempts = false, string $errorMessage = 'Value "%s" is invalid', bool $multiselect = false)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'select', [$question, $choices, $default, $attempts, $errorMessage, $multiselect]);
+    }
+
+    public function getAuthentications()
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getAuthentications', []);
+    }
+
+    public function resetAuthentications()
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'resetAuthentications', []);
+    }
+
+    public function hasAuthentication(string $repositoryName)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'hasAuthentication', [$repositoryName]);
+    }
+
+    public function getAuthentication(string $repositoryName)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getAuthentication', [$repositoryName]);
+    }
+
+    public function setAuthentication(string $repositoryName, string $username, ?string $password = null)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'setAuthentication', [$repositoryName, $username, $password]);
+    }
+
+    public function loadConfiguration(Config $config)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'loadConfiguration', [$config]);
+    }
+
+    public function emergency($message, array $context = []): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'emergency', [$message, $context]);
+    }
+
+    public function alert($message, array $context = []): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'alert', [$message, $context]);
+    }
+
+    public function critical($message, array $context = []): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'critical', [$message, $context]);
+    }
+
+    public function error($message, array $context = []): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'error', [$message, $context]);
+    }
+
+    public function warning($message, array $context = []): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'warning', [$message, $context]);
+    }
+
+    public function notice($message, array $context = []): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'notice', [$message, $context]);
+    }
+
+    public function info($message, array $context = []): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'info', [$message, $context]);
+    }
+
+    public function debug($message, array $context = []): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'debug', [$message, $context]);
+    }
+
+    public function log($level, $message, array $context = []): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'log', [$level, $message, $context]);
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/IO/BufferIO.php b/crates/shirabe-php-rpc/php/stubs/Composer/IO/BufferIO.php
new file mode 100644
index 00000000..e95fb2da
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/stubs/Composer/IO/BufferIO.php
@@ -0,0 +1,19 @@
+<?php
+
+// Hand-written proxy stub for Composer\IO\BufferIO, kept in the shape the future stub
+// generator will output.
+
+namespace Composer\IO;
+
+class BufferIO extends ConsoleIO
+{
+    public function getOutput(): string
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getOutput', []);
+    }
+
+    public function setUserInputs(array $inputs): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setUserInputs', [$inputs]);
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/IO/ConsoleIO.php b/crates/shirabe-php-rpc/php/stubs/Composer/IO/ConsoleIO.php
new file mode 100644
index 00000000..6a4c2ac4
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/stubs/Composer/IO/ConsoleIO.php
@@ -0,0 +1,27 @@
+<?php
+
+// Hand-written proxy stub for Composer\IO\ConsoleIO, kept in the shape the future stub
+// generator will output. The IOInterface surface is inherited from the BaseIO stub; only the
+// public methods ConsoleIO adds are declared here.
+
+namespace Composer\IO;
+
+use Symfony\Component\Console\Helper\Table;
+
+class ConsoleIO extends BaseIO
+{
+    public function enableDebugging(float $startTime)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'enableDebugging', [$startTime]);
+    }
+
+    public function getProgressBar(int $max = 0)
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getProgressBar', [$max]);
+    }
+
+    public function getTable(): Table
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getTable', []);
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/IO/NullIO.php b/crates/shirabe-php-rpc/php/stubs/Composer/IO/NullIO.php
new file mode 100644
index 00000000..92e01700
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/stubs/Composer/IO/NullIO.php
@@ -0,0 +1,10 @@
+<?php
+
+// Hand-written proxy stub for Composer\IO\NullIO, kept in the shape the future stub generator
+// will output. The whole surface is inherited from the BaseIO stub.
+
+namespace Composer\IO;
+
+class NullIO extends BaseIO
+{
+}
diff --git a/crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php b/crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php
new file mode 100644
index 00000000..7f085178
--- /dev/null
+++ b/crates/shirabe-php-rpc/php/stubs/Composer/PartialComposer.php
@@ -0,0 +1,113 @@
+<?php
+
+// Hand-written proxy stub for Composer\PartialComposer, kept in the shape the future stub
+// generator will output: the real public methods, each forwarding to the Rust-side entity.
+// Methods the Rust dispatcher does not support yet surface as explicit RPC errors.
+
+namespace Composer;
+
+use Composer\Autoload\AutoloadGenerator;
+use Composer\Config;
+use Composer\EventDispatcher\EventDispatcher;
+use Composer\Installer\InstallationManager;
+use Composer\Package\RootPackageInterface;
+use Composer\Repository\RepositoryManager;
+use Composer\Util\Loop;
+
+class PartialComposer implements \ShirabeRustStub
+{
+    /** @var int */
+    protected $__rhandle;
+    /** @var int */
+    protected $__epoch;
+
+    public function __construct(int $rhandle, int $epoch)
+    {
+        $this->__rhandle = $rhandle;
+        $this->__epoch = $epoch;
+    }
+
+    public function __destruct()
+    {
+        \ShirabeRustObjectRegistry::release($this->__rhandle);
+    }
+
+    public function __shirabeRustHandleDescriptor(): array
+    {
+        return [
+            '__rhandle' => $this->__rhandle,
+            '__class' => static::class,
+            '__epoch' => $this->__epoch,
+        ];
+    }
+
+    public function setPackage(RootPackageInterface $package): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setPackage', [$package]);
+    }
+
+    public function getPackage(): RootPackageInterface
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getPackage', []);
+    }
+
+    public function setConfig(Config $config): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setConfig', [$config]);
+    }
+
+    public function getConfig(): Config
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getConfig', []);
+    }
+
+    public function setLoop(Loop $loop): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setLoop', [$loop]);
+    }
+
+    public function getLoop(): Loop
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getLoop', []);
+    }
+
+    public function setRepositoryManager(RepositoryManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setRepositoryManager', [$manager]);
+    }
+
+    public function getRepositoryManager(): RepositoryManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getRepositoryManager', []);
+    }
+
+    public function setInstallationManager(InstallationManager $manager): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setInstallationManager', [$manager]);
+    }
+
+    public function getInstallationManager(): InstallationManager
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getInstallationManager', []);
+    }
+
+    public function setEventDispatcher(EventDispatcher $eventDispatcher): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setEventDispatcher', [$eventDispatcher]);
+    }
+
+    public function getEventDispatcher(): EventDispatcher
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'getEventDispatcher', []);
+    }
+
+    public function isGlobal(): bool
+    {
+        return \ShirabeRpcRuntime::callRust($this->__rhandle, 'isGlobal', []);
+    }
+
+    public function setGlobal(): void
+    {
+        \ShirabeRpcRuntime::callRust($this->__rhandle, 'setGlobal', []);
+    }
+}
diff --git a/crates/shirabe-php-rpc/php/worker.php b/crates/shirabe-php-rpc/php/worker.php
index ce11158e..d8f10e93 100644
--- a/crates/shirabe-php-rpc/php/worker.php
+++ b/crates/shirabe-php-rpc/php/worker.php
@@ -64,11 +64,66 @@ final class ShirabeRustObjectRegistry
     }
 }
 
+/**
+ * The P table: PHP-owned entities exposed to Rust, keyed by phandle. Entries are strong
+ * references — an entity stays alive until the Rust side sends ReleasePhpHandle.
+ */
+final class ShirabePhpObjectRegistry
+{
+    /** @var array<int, object> */
+    private static array $objects = [];
+    /** @var array<int, int> spl_object_id => phandle, so one entity keeps one handle */
+    private static array $handlesByObjectId = [];
+    private static int $nextPhandle = 1;
+
+    public static function register(object $obj): int
+    {
+        $objectId = spl_object_id($obj);
+        $existing = self::$handlesByObjectId[$objectId] ?? null;
+        if ($existing !== null && isset(self::$objects[$existing])) {
+            return $existing;
+        }
+        $phandle = self::$nextPhandle++;
+        self::$objects[$phandle] = $obj;
+        self::$handlesByObjectId[$objectId] = $phandle;
+        return $phandle;
+    }
+
+    public static function get(int $phandle): object
+    {
+        if (!isset(self::$objects[$phandle])) {
+            throw new RuntimeException("unknown PHP handle {$phandle}");
+        }
+        return self::$objects[$phandle];
+    }
+
+    public static function release(int $phandle): void
+    {
+        $obj = self::$objects[$phandle] ?? null;
+        unset(self::$objects[$phandle]);
+        if ($obj !== null) {
+            unset(self::$handlesByObjectId[spl_object_id($obj)]);
+        }
+    }
+
+    /** @return array{__phandle: int, __class: string, __implements: list<string>} */
+    public static function descriptor(object $obj): array
+    {
+        return [
+            '__phandle' => self::register($obj),
+            '__class' => get_class($obj),
+            '__implements' => array_values(class_implements($obj)),
+        ];
+    }
+}
+
 final class ShirabeRpcRuntime
 {
     /** @var resource */
     public static $socket;
     public static ?string $stubsDir = null;
+    /** @var ?callable(string): void */
+    public static $stubAutoloader = null;
     /** @var array<string, callable(array): mixed> */
     public static array $dispatch = [];
     /** Even correlation ids; the Rust side allocates odd ones. */
@@ -147,11 +202,7 @@ final class ShirabeRpcRuntime
             return $value->__shirabeRustHandleDescriptor();
         }
         if (is_object($value)) {
-            // TODO(plugin): PHP-owned objects (the P table) are not implemented yet; only Rust
-            // proxy stubs can cross the boundary until the plugin activation milestone.
-            throw new RuntimeException(
-                'returning a PHP object over RPC is not supported yet: ' . get_class($value)
-            );
+            return ShirabePhpObjectRegistry::descriptor($value);
         }
         if (is_resource($value)) {
             throw new RuntimeException('a PHP resource cannot cross the RPC boundary');
@@ -176,8 +227,7 @@ final class ShirabeRpcRuntime
             );
         }
         if (isset($value['__phandle'])) {
-            // TODO(plugin): the P table is not implemented yet.
-            throw new RuntimeException('__phandle descriptors are not supported yet');
+            return ShirabePhpObjectRegistry::get((int) $value['__phandle']);
         }
         if (isset($value['__pclass']) && count($value) === 1) {
             return $value['__pclass'];
@@ -261,19 +311,31 @@ final class ShirabeRpcRuntime
                 });
                 break;
             case SHIRABE_TAG_NEW_OBJECT:
-                self::replyWith($corrId, static function () {
-                    // TODO(plugin): requires the P table (plugin activation milestone M2).
-                    throw new RuntimeException('NewObject is not supported yet');
+                [$class, $ctorArgs] = $fields;
+                self::replyWith($corrId, static function () use ($class, $ctorArgs) {
+                    $ctorArgs = ShirabeRpcRuntime::fromWire($ctorArgs);
+                    if (!class_exists($class)) {
+                        throw new RuntimeException("PHP class `{$class}` does not exist");
+                    }
+                    return new $class(...$ctorArgs);
                 });
                 break;
             case SHIRABE_TAG_CALL_PHP_METHOD:
-                self::replyWith($corrId, static function () {
-                    // TODO(plugin): requires the P table (plugin activation milestone M2).
-                    throw new RuntimeException('CallPhpMethod is not supported yet');
+                [$phandle, $method, $args] = $fields;
+                self::replyWith($corrId, static function () use ($phandle, $method, $args) {
+                    $obj = ShirabePhpObjectRegistry::get((int) $phandle);
+                    $args = ShirabeRpcRuntime::fromWire($args);
+                    if (!is_callable([$obj, $method])) {
+                        throw new RuntimeException(
+                            get_class($obj) . "::{$method} is not callable"
+                        );
+                    }
+                    return $obj->$method(...$args);
                 });
                 break;
             case SHIRABE_TAG_RELEASE_PHP_HANDLE:
-                // TODO(plugin): the P table is not implemented yet; nothing to release.
+                [$phandle] = $fields;
+                ShirabePhpObjectRegistry::release((int) $phandle);
                 break;
             case SHIRABE_TAG_EPOCH_BUMP:
                 [$rhandle, $epoch] = $fields;
@@ -308,6 +370,16 @@ final class ShirabeRpcRuntime
      * resolved by asking the Rust-side ClassLoader (built by EventDispatcher::makeAutoloader)
      * where the class file lives. Handle 0 is the runtime service endpoint on the Rust side.
      */
+    /** Re-prepends the stub autoloader so it precedes any autoloader registered since. */
+    public static function ensureStubAutoloaderPriority(): void
+    {
+        if (self::$stubAutoloader === null) {
+            return;
+        }
+        spl_autoload_unregister(self::$stubAutoloader);
+        spl_autoload_register(self::$stubAutoloader, true, true);
+    }
+
     public static function enableScriptAutoloader(): void
     {
         if (self::$scriptAutoloaderRegistered) {
@@ -332,8 +404,9 @@ ShirabeRpcRuntime::$stubsDir = $argv[2] ?? null;
 
 // Proxy stub classes take priority over any other autoloader (including autoloaders that a
 // script or the composer runtime registers later), so a proxied FQCN can never be shadowed by
-// the real implementation.
-spl_autoload_register(static function (string $class): void {
+// the real implementation. `__shirabe_require` re-prepends this closure after loading code
+// that registers its own prepending autoloader.
+ShirabeRpcRuntime::$stubAutoloader = static function (string $class): void {
     if (ShirabeRpcRuntime::$stubsDir === null) {
         return;
     }
@@ -341,7 +414,8 @@ spl_autoload_register(static function (string $class): void {
     if (is_file($file)) {
         require $file;
     }
-}, true, true);
+};
+spl_autoload_register(ShirabeRpcRuntime::$stubAutoloader, true, true);
 
 // Port of Composer\XdebugHandler\XdebugHandler::setXdebugDetails(), which the diagnose payload
 // reports as `xdebug_active`.
@@ -481,12 +555,47 @@ ShirabeRpcRuntime::$dispatch = [
     '__shirabe_oracle_roundtrip' => static fn($args) => serialize(unserialize($args[0], ['allowed_classes' => false])),
     '__shirabe_require' => static function ($args) {
         require_once $args[0];
+        // The required file may have registered further prepending autoloaders (a Composer
+        // vendor/autoload.php prepends its ClassLoader); proxied FQCNs must stay resolvable to
+        // the stub classes, so the stub autoloader is moved back to the front of the stack.
+        ShirabeRpcRuntime::ensureStubAutoloaderPriority();
         return true;
     },
     '__shirabe_enable_script_autoloader' => static function ($args) {
         ShirabeRpcRuntime::enableScriptAutoloader();
         return true;
     },
+    // The body of \Composer\Autoload\composerRequire (AutoloadGenerator.php), sharing its
+    // $GLOBALS guard so files already required by a real Composer autoloader in this process
+    // are not required twice.
+    '__shirabe_composer_require' => static function ($args) {
+        [$fileIdentifier, $file] = $args;
+        if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) {
+            $GLOBALS['__composer_autoload_files'][$fileIdentifier] = true;
+
+            require $file;
+        }
+        return true;
+    },
+    // Mirrors FilesystemRepository::write's in-process `InstalledVersions::reload($versions)`
+    // into this child. The class_exists guard (no autoload) matches the upstream observable
+    // behavior: when the class was never loaded here, a later lazy load reads the
+    // freshly-written installed.php anyway.
+    '__shirabe_installed_versions_reload' => static function ($args) {
+        if (class_exists('Composer\\InstalledVersions', false)) {
+            \Composer\InstalledVersions::reload($args[0]);
+        }
+        return true;
+    },
+    // For testing only: reads a public property of a P-table entity (PHPUnit asserts like
+    // `$plugins[0]->version` have no method to call).
+    '__shirabe_get_property' => static function ($args) {
+        $obj = ShirabeRpcRuntime::fromWire($args[0]);
+        if (!is_object($obj)) {
+            throw new RuntimeException('__shirabe_get_property expects a handle argument');
+        }
+        return $obj->{$args[1]};
+    },
 ];
 
 ShirabeRpcRuntime::serveForever();