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>

1 files changed, 6 insertions, 10 deletions

diff --git a/crates/shirabe/src/factory.rs b/crates/shirabe/src/factory.rs
index 29dc3e05..903f6d35 100644
--- a/crates/shirabe/src/factory.rs
+++ b/crates/shirabe/src/factory.rs
@@ -42,7 +42,6 @@ use crate::plugin::PluginEvents;
 use crate::plugin::PluginManager;
 use crate::repository::FilesystemRepository;
 use crate::repository::InstalledFilesystemRepository;
-use crate::repository::InstalledRepositoryInterface;
 use crate::repository::RepositoryFactory;
 use crate::repository::RepositoryManager;
 use crate::util::Filesystem;
@@ -892,13 +891,9 @@ impl Factory {
             // once everything is initialized we can
             // purge packages from local repos if they have been deleted on the filesystem
             // PHP: $this->purgePackages($rm->getLocalRepository(), $im);
-            // TODO(phase-c): the rm/im locals are still in scope (Rc-shared with composer), but
-            // purge_packages wants `&mut dyn InstalledRepositoryInterface` and
-            // RepositoryManager::get_local_repository yields a RepositoryInterfaceHandle that
-            // exposes no raw &mut InstalledRepositoryInterface view (only per-method helpers that
-            // borrow internally). Wiring this needs such an accessor plus completing
-            // purge_packages' removal body (repo.removePackage), which is itself still a stub.
-            // self.purge_packages(rm.get_local_repository(), &mut im)?;
+            // TODO(phase-c): purge_packages' removal body (repo.removePackage for packages
+            // deleted on the filesystem) is still a stub; wire this call once implemented.
+            // self.purge_packages(&InstalledRepositoryInterfaceHandle::from_repository_handle(&rm.get_local_repository()), &mut im)?;
         }
 
         Ok(PartialComposerHandle::from_rc(composer))
@@ -1316,10 +1311,11 @@ impl Factory {
 
     fn purge_packages(
         &self,
-        repo: &mut dyn InstalledRepositoryInterface,
+        repo: &crate::repository::InstalledRepositoryInterfaceHandle,
         im: &mut InstallationManager,
     ) -> anyhow::Result<()> {
-        for package in repo.get_packages()? {
+        let packages = repo.borrow_mut().get_packages()?;
+        for package in packages {
             if !im.is_package_installed(repo, package.clone())? {
                 let _ = package;
             }