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>

5 files changed, 84 insertions, 12 deletions

diff --git a/crates/shirabe/src/repository/filesystem_repository.rs b/crates/shirabe/src/repository/filesystem_repository.rs
index 32e4022a..b2a2530e 100644
--- a/crates/shirabe/src/repository/filesystem_repository.rs
+++ b/crates/shirabe/src/repository/filesystem_repository.rs
@@ -343,10 +343,20 @@ impl FilesystemRepository {
             );
 
             // make sure the in memory state is up to date with on disk
-            // TODO(plugin): whether this reload must also be pushed to the plugin PHP child
-            // process is undecided; the InstalledVersions state a plugin observes after this
-            // dump is undefined (docs/dev/plugin-class-classification.md, "Bootstrap classes
-            // cannot be stub-shadowed").
+            // The upstream in-process reload is split in two here: the Rust-side mirror below,
+            // and a push into the PHP worker where the real observers (plugins) live. The push
+            // is skipped when no worker is running — with no child there is nothing that could
+            // observe the stale state, and the worker glue additionally ignores it while the
+            // class is not loaded there (a later lazy load reads the freshly written
+            // installed.php, matching upstream observations in every case).
+            if shirabe_php_rpc::worker_is_running() {
+                crate::event_dispatcher::unwrap_php_result(shirabe_php_rpc::call_function(
+                    "__shirabe_installed_versions_reload",
+                    vec![shirabe_php_rpc::PluginValue::from_php_mixed(
+                        &PhpMixed::Array(versions.clone()),
+                    )],
+                ))?;
+            }
             InstalledVersions::reload(versions);
 
             // make sure the selfDir matches the expected data at runtime if the class was loaded from the vendor dir, as it may have been
diff --git a/crates/shirabe/src/repository/handle.rs b/crates/shirabe/src/repository/handle.rs
index 2a7239b9..1e24085b 100644
--- a/crates/shirabe/src/repository/handle.rs
+++ b/crates/shirabe/src/repository/handle.rs
@@ -3,8 +3,8 @@
 use crate::package::BasePackageHandle;
 use crate::package::PackageInterfaceHandle;
 use crate::repository::{
-    FindPackageConstraint, LoadPackagesResult, LockArrayRepository, PlatformRepository,
-    ProviderInfo, RepositoryInterface, SearchResult,
+    FindPackageConstraint, InstalledRepositoryInterface, LoadPackagesResult, LockArrayRepository,
+    PlatformRepository, ProviderInfo, RepositoryInterface, SearchResult,
 };
 use indexmap::IndexMap;
 use shirabe_semver::constraint::AnyConstraint;
@@ -192,6 +192,62 @@ impl RepositoryInterfaceHandle {
     }
 }
 
+/// Shared handle over a repository known to implement `InstalledRepositoryInterface`.
+///
+/// The installer pipeline passes this instead of a long-lived `&mut dyn
+/// InstalledRepositoryInterface` so that re-entrant access to the same repository through
+/// `RepositoryManager::get_local_repository()` — e.g. `PluginManager::register_package` running
+/// inside `InstallationManager::execute` — borrows the shared `RefCell` only transiently.
+#[derive(Debug, Clone)]
+pub struct InstalledRepositoryInterfaceHandle(
+    std::rc::Rc<std::cell::RefCell<dyn RepositoryInterface>>,
+);
+
+impl InstalledRepositoryInterfaceHandle {
+    pub fn new<T: RepositoryInterface + 'static>(repository: T) -> Self {
+        Self::from_repository_handle(&RepositoryInterfaceHandle::new(repository))
+    }
+
+    /// PHP has no counterpart for this narrowing: parameters typed
+    /// `InstalledRepositoryInterface` simply receive such an instance. Handing over a
+    /// repository that is not one is a programming error.
+    pub fn from_repository_handle(handle: &RepositoryInterfaceHandle) -> Self {
+        assert!(
+            handle.is_installed_repository_interface(),
+            "repository does not implement InstalledRepositoryInterface"
+        );
+        Self(handle.as_rc().clone())
+    }
+
+    pub fn as_repository_handle(&self) -> RepositoryInterfaceHandle {
+        RepositoryInterfaceHandle::from_rc(self.0.clone())
+    }
+
+    pub fn borrow(&self) -> Ref<'_, dyn InstalledRepositoryInterface> {
+        Ref::map(self.0.borrow(), |r| {
+            r.as_installed_repository_interface()
+                .expect("checked at handle construction")
+        })
+    }
+
+    pub fn borrow_mut(&self) -> RefMut<'_, dyn InstalledRepositoryInterface> {
+        RefMut::map(self.0.borrow_mut(), |r| {
+            r.as_installed_repository_interface_mut()
+                .expect("checked at handle construction")
+        })
+    }
+
+    /// PHP `===` (reference identity).
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        std::rc::Rc::ptr_eq(&self.0, &other.0)
+    }
+
+    /// Stable identity usable as a map key (PHP `spl_object_hash`).
+    pub fn ptr_id(&self) -> usize {
+        std::rc::Rc::as_ptr(&self.0) as *const () as usize
+    }
+}
+
 impl PartialEq for RepositoryInterfaceHandle {
     fn eq(&self, other: &Self) -> bool {
         std::rc::Rc::ptr_eq(&self.0, &other.0)
diff --git a/crates/shirabe/src/repository/installed_array_repository.rs b/crates/shirabe/src/repository/installed_array_repository.rs
index c0c0fbb7..9483a1a9 100644
--- a/crates/shirabe/src/repository/installed_array_repository.rs
+++ b/crates/shirabe/src/repository/installed_array_repository.rs
@@ -137,12 +137,14 @@ impl RepositoryInterface for InstalledArrayRepository {
     fn as_advisory_provider(&self) -> Option<&dyn AdvisoryProviderInterface> {
         None
     }
-    fn as_installed_repository_interface(&self) -> Option<&dyn InstalledRepositoryInterface> {
+    fn as_installed_repository_interface(
+        &self,
+    ) -> Option<&(dyn InstalledRepositoryInterface + 'static)> {
         Some(self)
     }
     fn as_installed_repository_interface_mut(
         &mut self,
-    ) -> Option<&mut dyn InstalledRepositoryInterface> {
+    ) -> Option<&mut (dyn InstalledRepositoryInterface + 'static)> {
         Some(self)
     }
     fn as_writable_repository_interface_mut(
diff --git a/crates/shirabe/src/repository/installed_filesystem_repository.rs b/crates/shirabe/src/repository/installed_filesystem_repository.rs
index 0bb962fd..1986f32a 100644
--- a/crates/shirabe/src/repository/installed_filesystem_repository.rs
+++ b/crates/shirabe/src/repository/installed_filesystem_repository.rs
@@ -171,12 +171,14 @@ impl RepositoryInterface for InstalledFilesystemRepository {
     fn as_advisory_provider(&self) -> Option<&dyn AdvisoryProviderInterface> {
         None
     }
-    fn as_installed_repository_interface(&self) -> Option<&dyn InstalledRepositoryInterface> {
+    fn as_installed_repository_interface(
+        &self,
+    ) -> Option<&(dyn InstalledRepositoryInterface + 'static)> {
         Some(self)
     }
     fn as_installed_repository_interface_mut(
         &mut self,
-    ) -> Option<&mut dyn InstalledRepositoryInterface> {
+    ) -> Option<&mut (dyn InstalledRepositoryInterface + 'static)> {
         Some(self)
     }
     fn as_writable_repository_interface_mut(
diff --git a/crates/shirabe/src/repository/repository_interface.rs b/crates/shirabe/src/repository/repository_interface.rs
index cece0d6f..ed1022f4 100644
--- a/crates/shirabe/src/repository/repository_interface.rs
+++ b/crates/shirabe/src/repository/repository_interface.rs
@@ -107,15 +107,17 @@ pub trait RepositoryInterface: std::fmt::Debug {
         None
     }
 
+    // The `+ 'static` object bound lets `InstalledRepositoryInterfaceHandle` project a
+    // `Ref`/`RefMut` through this method (`Ref::map` needs a lifetime-independent target).
     fn as_installed_repository_interface(
         &self,
-    ) -> Option<&dyn crate::repository::InstalledRepositoryInterface> {
+    ) -> Option<&(dyn crate::repository::InstalledRepositoryInterface + 'static)> {
         None
     }
 
     fn as_installed_repository_interface_mut(
         &mut self,
-    ) -> Option<&mut dyn crate::repository::InstalledRepositoryInterface> {
+    ) -> Option<&mut (dyn crate::repository::InstalledRepositoryInterface + 'static)> {
         None
     }